rk_stubby.c

Go to the documentation of this file.

/*
 * rk_stubby.c
 *
 * Copyright (c) 2003 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file rk_stubby.c
 *
 * A simple tool for simulating real-time processes using rk_stub.
 */

#include "config.h"

#include <stdio.h>
#include <string.h>

#include <rk.h>

#if !defined(RK_STUB)
#error "This file only works with the rk_stub library"
#endif

#include <rk_stub.h>
#include "time_util.h"

/**
 * Enumeration of the different verbosity levels.
 */
typedef enum {
    VERBOSITY_NONE,
    VERBOSITY_DELEGATE,
} rk_stubby_verbosity_t;

/**
 * The current verbosity level.
 */
static rk_stubby_verbosity_t verbosity = VERBOSITY_NONE;

/**
 * The object that holds the CPU reservation parameters.
 */
static struct cpu_reserve_attr cra = {
    { 1, 0 },
    { 2, 0 },
    { 2, 0 },
    { 0, 0 },
    { 0, 0 },
    { RSV_SOFT, RSV_SOFT, RSV_SOFT },
    RK_ANY_CPU,
};

/**
 * The name of the resource set that will be created.
 */
static char *test_name = "test";

/**
 * Flag that indicates that all data should be dropped.
 */
static int drop_all = 0;

/**
 * Flag that indicates that data should be dropped when the process is behind.
 */
static int drop_behind = 0;

/**
 * The ending time for the simulation run.
 */
static struct timespec run_end = { 4, 0 };

/**
 * Interpret a string as a boolean value.
 *
 * @param str The string to interpret.
 * @return True if the string case insensitively matches one of the following
 *         values: true, yes, 1, on.  Otherwise, the function returns false.
 */
static int parse_boolean(char *str)
{
    static char *trueValues[] = {
        "true",
        "yes",
        "1",
        "on",
        0
    };
    
    int lpc, retval = 0;

    for( lpc = 0; !retval && trueValues[lpc]; lpc++ )
    {
        if( strcasecmp(trueValues[lpc], str) == 0 )
            retval = 1;
    }
    return retval;
}

/**
 * The fake process' data.
 */
static struct {
    struct timespec start;
    int data_period;
    int time_period;
} c1_data;

/**
 * The function that will be called by the simulator when a new data period
 * is started.
 *
 * @param data The process' data.
 * @return RKSP_OK if drop_all == false and drop_behind == false or the process
 *         is making its deadlines.  Otherwise, it returns RKSP_DROP.
 */
static rk_stub_precall_retval_t c1_pre(void *data)
{
    rk_stub_precall_retval_t retval = RKSP_OK;
    struct timespec ts;

    clock_gettime(CLOCK_REALTIME, &ts);
    if( verbosity >= VERBOSITY_DELEGATE )
    {
        printf("%s { %ld, %ld }\n",
               __PRETTY_FUNCTION__,
               ts.tv_sec,
               ts.tv_nsec);
    }
    {
        unsigned long long period_us, curr_us;

        period_us = timespec_to_microsec(&cra.period);
        curr_us = timespec_to_microsec(&ts);
        /* Compute which 'time' period we're in. */
        c1_data.time_period = (curr_us + (period_us - 1)) / period_us;
    }
    c1_data.start = ts;
    if( drop_all )
    {
        retval = RKSP_DROP;
    }
    if( drop_behind && (c1_data.data_period < c1_data.time_period) )
    {
        /* We're dropping it, advance to the next data period. */
        c1_data.data_period += 1;
        if( verbosity >= VERBOSITY_DELEGATE )
        {
            printf("Dropping at %d, %d\n",
                   c1_data.data_period,
                   c1_data.time_period);
        }
        retval = RKSP_DROP;
    }
    else
    {
        if( verbosity >= VERBOSITY_DELEGATE )
        {
            printf("No drop at %d, %d\n",
                   c1_data.data_period,
                   c1_data.time_period);
        }
    }
    return( retval );
}

/**
 * The function that will be called by the simulator when a data period
 * is finished.
 *
 * @param data The process' data.
 */
void c1_post(void *data)
{
    struct timespec ts;

    c1_data.data_period += 1;
    clock_gettime(CLOCK_REALTIME, &ts);
    if( verbosity >= VERBOSITY_DELEGATE )
    {
        printf("%s { %ld, %ld }\n",
               __PRETTY_FUNCTION__,
               ts.tv_sec,
               ts.tv_nsec);
    }
}

int main(int argc, char *argv[])
{
    int lpc, retval = EXIT_SUCCESS;
    pid_t c1;

    rk_stub_set_mode(RK_STUB_SIM);

    if( ((argc - 1) % 2) != 0 )
    {
        fprintf(stderr, "Error: Odd number of arguments");
        retval = EXIT_FAILURE;
    }
    else
    {
        for( lpc = 1; (lpc < argc) && (retval == EXIT_SUCCESS); lpc += 2 )
        {
            if( strcmp(argv[lpc], "-name") == 0 )
            {
                test_name = argv[lpc + 1];
            }
            else if( strcmp(argv[lpc], "-verbosity") == 0 )
            {
                if( sscanf(argv[lpc + 1],
                           "%d",
                           (int *)&verbosity) == 0 )
                {
                    fprintf(stderr,
                            "-verbosity value is not a number: %s\n",
                            argv[lpc + 1]);
                }
            }
            else if( strcmp(argv[lpc], "-compute_sec") == 0 )
            {
                if( sscanf(argv[lpc + 1],
                           "%d",
                           (int *)&cra.compute_time.tv_sec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-compute_sec value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-compute_ns") == 0 )
            {
                if( sscanf(argv[lpc + 1],
                           "%d",
                           (int *)&cra.compute_time.tv_nsec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-compute_ns value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-period_sec") == 0 )
            {
                if( sscanf(argv[lpc + 1], "%d", (int *)&cra.period.tv_sec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-period_sec value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-period_ns") == 0 )
            {
                if( sscanf(argv[lpc + 1], "%d", (int *)&cra.period.tv_nsec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-period_ns value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-deadline_sec") == 0 )
            {
                if( sscanf(argv[lpc + 1], "%d", (int *)&cra.deadline.tv_sec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-deadline_sec value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-deadline_ns") == 0 )
            {
                if( sscanf(argv[lpc + 1], "%d", (int *)&cra.deadline.tv_nsec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-deadline_ns value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-start_sec") == 0 )
            {
                if( sscanf(argv[lpc + 1],
                           "%d",
                           (int *)&cra.start_time.tv_sec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-start_sec value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-start_ns") == 0 )
            {
                if( sscanf(argv[lpc + 1],
                           "%d",
                           (int *)&cra.start_time.tv_nsec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-start_ns value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-for") == 0 )
            {
                if( sscanf(argv[lpc + 1], "%d", (int *)&run_end.tv_sec)
                    == 0 )
                {
                    fprintf(stderr,
                            "-for value is not a number: %s\n",
                            argv[lpc + 1]);
                    retval = EXIT_FAILURE;
                }
            }
            else if( strcmp(argv[lpc], "-drop_all") == 0 )
            {
                drop_all = parse_boolean(argv[lpc + 1]);
            }
            else if( strcmp(argv[lpc], "-drop_behind") == 0 )
            {
                drop_behind = parse_boolean(argv[lpc + 1]);
            }
            else
            {
                fprintf(stderr,
                        "Unknown argument: %s\n",
                        argv[lpc]);
                retval = EXIT_FAILURE;
            }
        }
        if( (retval == EXIT_SUCCESS) &&
            (c1 = rk_stub_mk_pid(test_name, &c1_data, c1_pre, c1_post)) >= 0 )
        {
            rk_resource_set_t rs;

            if( (rs = rk_resource_set_create(test_name)) != NULL )
            {
                int rc;
                
                if( (rc = rk_resource_set_attach_process(rs, c1)) == 0 )
                {
                    rk_reserve_t cr;
                    
                    if( (rc = rk_cpu_reserve_create(rs, &cr, &cra)) == 0 )
                    {
                        struct timespec curr = { 0, 0 };
                        
                        do {
                            rk_stub_next_tick();
                            clock_gettime(CLOCK_REALTIME, &curr);
                        } while( curr.tv_sec < run_end.tv_sec );
                    }
                    else
                    {
                        fprintf(stderr,
                                "rk_cpu_reserve_create: %s\n",
                                strerror(rc));
                    }
                }
                else
                {
                    fprintf(stderr,
                            "rk_resource_set_attach_process: %s\n",
                            strerror(rc));
                }
                rk_resource_set_destroy(rs);
            }
            else
            {
                perror("rk_resource_set_create");
            }
        }
        else
        {
            perror("rk_stub_mk_pid");
        }
    }
    return( retval );
}

---