rk_stub.c

Go to the documentation of this file.

/*
 * rk_stub.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_stub.c
 *
 * The implementation of the resource kernel (rk) simulator.
 */

#include "config.h"

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include <ctype.h>

#include "rk.h"
#include "rk_stub.h"

#include "assert_pp.h"
#include "time_util.h"

/* Macros */

#if !defined(max)
/** Return the maximum of two values. */
#define max(x, y) \
        ((x) > (y) ? (x) : (y))
#endif

#if !defined(min)
/** Return the minimum of two values. */
#define min(x, y) \
        ((x) < (y) ? (x) : (y))
#endif

/* Static data */

/** Global data for the rk_stub functions. */
struct rk_stub_data rk_stub_data;

/* Static function protos */

/**
 * Function used to advance simulated time.
 *
 * @param rs The resource set that has processes that will consume resources.
 * @param cr The cpu_reserve_t of the resource set.
 * @param curr The current time.
 * @param next The next time a simulated event will occur.
 * @param new_compute NULL or the resource set's new computation time.
 */
static
void rk_cpu_reserve_tick(rk_resource_set_t rs,
                         cpu_reserve_t cr,
                         struct timespec *curr,
                         struct timespec *next,
                         struct timespec *new_compute);

/** The string forms of the trace file enumeration. */
static char *rk_cpu_trace_names[RK_CPU_TRACE_MAX] = {
    "period",
    "deadline",
    "complete",
    "drop",
    "realtime",
    "success",
    "fail"
};

/* BEGIN validation functions **/

/**
 * Validate a user provided name value.  Currently, the only test is whether or
 * not the name is printable.
 *
 * @param name The name to validate.
 * @return True if the parameter is valid, false otherwise.
 */
static int rk_name_valid(const char *name)
{
    int lpc, retval = 1;

    require(name != NULL);
    
    for( lpc = 0; name[lpc] && retval; lpc++ )
    {
        retval = isprint(name[lpc]);
    }
    return( retval );
}

/**
 * Validate a user provided rk_reserve_mode_t value.  The only valid values
 * are listed in the enumeration.
 *
 * @param rm The rk_reserve_mode_t to validate.
 * @return True if the parameter is valid, false otherwise.
 */
static int rk_reserve_mode_valid(rk_reserve_mode_t rm)
{
    int retval = 0;

    switch( rm )
    {
    case RSV_HARD:
    case RSV_FIRM:
    case RSV_SOFT:
        retval = 1;
        break;
    default:
        retval = 0;
        break;
    }
    return( retval );
}

/**
 * Validate a user provided rk_reserve_param_t value.  A valid
 * rk_reserve_param_t must have the following attributes:
 *
 * @li rk_reserve_mode_valid(sch_mode) == 1
 * @li rk_reserve_mode_valid(enf_mode) == 1
 * @li rk_reserve_mode_valid(rep_mode) == 1
 *
 * @param rp The rk_reserve_param_t to validate.
 * @return True if the parameter is valid, false otherwise.
 */
static int rk_reserve_param_valid(rk_reserve_param_t rp)
{
    int retval = 1;

    if( !rk_reserve_mode_valid(rp->sch_mode) ||
        !rk_reserve_mode_valid(rp->enf_mode) ||
        !rk_reserve_mode_valid(rp->rep_mode) )
    {
        retval = 0;
    }
    return( retval );
}

/**
 * Validate a user provided cpu_reserve_attr_t value.  A valid reserve must
 * have the following attributes:
 *
 * @li period >= RT_MIN_PERIOD
 * @li compute_time <= deadline
 * @li deadline > 0
 * @li deadline <= period
 * @li rk_reserve_param_valid(reserve_type) == 1
 *
 * @param ra_in The cpu_reserve_attr_t to validate.
 * @return True if the parameter is valid, false otherwise.
 */
static int rk_cpu_reserve_attr_valid(cpu_reserve_attr_t ra_in)
{
    static struct timespec zero = { 0, 0 };
    static struct timespec min_period = RT_MIN_PERIOD;
    
    int retval = 1;

    require(ra_in != NULL);
    
    if( tscmp(&ra_in->period, &min_period, <) ||
        tscmp(&ra_in->compute_time, &ra_in->deadline, >) ||
        tscmp(&ra_in->deadline, &zero, ==) ||
        tscmp(&ra_in->deadline, &ra_in->period, >) ||
        !rk_reserve_param_valid(&ra_in->reserve_type) )
    {
        retval = 0;
    }
    return( retval );
}

/**
 * Validate a user provided cpu_reserve_t value.  Validation is done by
 * checking the pointer against the internal list of resource sets.
 *
 * @param cr The cpu_reserve_t to validate.
 * @return True if the parameter is valid, false otherwise.
 */
static int cpu_reserve_valid(cpu_reserve_t cr)
{
    rk_resource_set_t curr;
    int retval = 0;

    require(cr != NULL);
    
    curr = (rk_resource_set_t)rk_stub_data.sd_ResourceSets.lh_Head;
    while( curr->rs_Link.ln_Succ && !retval )
    {
        if( curr->rs_CPU == cr )
        {
            retval = 1;
        }
        curr = (rk_resource_set_t)curr->rs_Link.ln_Succ;
    }
    return( retval );
}

/**
 * Validate a user provided rk_resource_set_t value.  Validation is done by
 * checking the pointer against the internal list of resource sets.
 *
 * @param rs The rk_resource_set_t to validate.
 * @return True if the parameter is valid, false otherwise.
 */
static int rk_resource_set_valid(rk_resource_set_t rs)
{
    rk_resource_set_t curr;
    int retval = 0;

    require(rs != NULL);
    
    curr = (rk_resource_set_t)rk_stub_data.sd_ResourceSets.lh_Head;
    while( curr->rs_Link.ln_Succ && !retval )
    {
        if( curr == rs )
        {
            retval = 1;
        }
        curr = (rk_resource_set_t)curr->rs_Link.ln_Succ;
    }
    return( retval );
}

/* END validation functions **/

/* BEGIN object -> string functions **/

/**
 * Get the string version of an rk_reserve_mode_t value.
 *
 * @param rm The rk_reserve_mode_t to stringify.
 * @return A statically allocated string that corresponds to the parameter.
 */
static char *rk_reserve_mode_string(rk_reserve_mode_t rm)
{
    char *retval;
    
    switch( rm )
    {
    case RSV_HARD:
        retval = "HARD";
        break;
    case RSV_FIRM:
        retval = "FIRM";
        break;
    case RSV_SOFT:
        retval = "SOFT";
        break;
    default:
        retval = "invalid";
        break;
    }
    return( retval );
}

/**
 * Get the string version of an rk_reserve_param_t value.
 *
 * @param rp The rk_reserve_param_t to stringify or NULL.
 * @return A statically allocated string formatted with the values in the
 *         parameter.
 */
static char *rk_reserve_param_string(rk_reserve_param_t rp)
{
    static char retval[128];

    if( rp != NULL )
    {
        sprintf(retval,
                "[sch_mode=%s; enf_mode=%s; rep_mode=%s]",
                rk_reserve_mode_string(rp->sch_mode),
                rk_reserve_mode_string(rp->enf_mode),
                rk_reserve_mode_string(rp->rep_mode));
    }
    else
    {
        sprintf(retval, "(null)");
    }
    
    return( retval );
}

/**
 * Get the string version of a cpu_reserve_attr_t value.
 *
 * @param ra The cpu_reserve_attr_t to stringify or NULL.
 * @return A statically allocated string formatted with the values in the
 *         parameter.
 */
static char *cpu_reserve_attr_string(cpu_reserve_attr_t ra)
{
    static char retval[1024];

    if( ra != NULL )
    {
        sprintf(retval,
                "[compute_time=%d.%ld"
                "; period=%d.%ld"
                "; deadline=%d.%ld"
                "; blocking_time=%d.%ld"
                "; start_time=%d.%ld"
                "; reserve_type=%s"
                "; processor=%d]",
                (int)ra->compute_time.tv_sec,
                ra->compute_time.tv_nsec,
                (int)ra->period.tv_sec,
                ra->period.tv_nsec,
                (int)ra->deadline.tv_sec,
                ra->deadline.tv_nsec,
                (int)ra->blocking_time.tv_sec,
                ra->blocking_time.tv_nsec,
                (int)ra->start_time.tv_sec,
                ra->start_time.tv_nsec,
                rk_reserve_param_string(&ra->reserve_type),
                ra->processor);
    }
    else
    {
        sprintf(retval, "(null)");
    }
    
    return( retval );
}

/**
 * Get the string version of a cpu_reserve_t value.
 *
 * @param cr The cpu_reserve_t to stringify or NULL.
 * @return A statically allocated string formatted with the values in the
 *         parameter.
 */
static char *cpu_reserve_string(cpu_reserve_t cr)
{
    static char retval[1024];

    if( cr != NULL )
    {
        sprintf(retval,
                "[cr_Attributes=%s"
                "; cr_Flags=%lx"
                "; cr_Times=%p" // XXX
                "; cr_Length=%d"
                "; cr_DataIndex=%d"
                "; cr_TimeIndex=%d"
                "; cr_DataPeriodStart=%d.%ld"
                "; cr_DataPeriodEnd=%d.%ld"
                "; cr_DataPeriodNext=%d.%ld"
                "; cr_TimePeriodStart=%d.%ld"
                "; cr_TimePeriodEnd=%d.%ld"
                "; cr_TimePeriodNext=%d.%ld]",
                cpu_reserve_attr_string(&cr->cr_Attributes),
                cr->cr_Flags,
                cr->cr_Compute.cr_Times,
                cr->cr_Compute.cr_Length,
                cr->cr_Compute.cr_DataIndex,
                cr->cr_Compute.cr_TimeIndex,
                (int)cr->cr_Compute.cr_DataPeriodStart.tv_sec,
                cr->cr_Compute.cr_DataPeriodStart.tv_nsec,
                (int)cr->cr_Compute.cr_DataPeriodEnd.tv_sec,
                cr->cr_Compute.cr_DataPeriodEnd.tv_nsec,
                (int)cr->cr_Compute.cr_DataPeriodNext.tv_sec,
                cr->cr_Compute.cr_DataPeriodNext.tv_nsec,
                (int)cr->cr_Compute.cr_TimePeriodStart.tv_sec,
                cr->cr_Compute.cr_TimePeriodStart.tv_nsec,
                (int)cr->cr_Compute.cr_TimePeriodEnd.tv_sec,
                cr->cr_Compute.cr_TimePeriodEnd.tv_nsec,
                (int)cr->cr_Compute.cr_TimePeriodNext.tv_sec,
                cr->cr_Compute.cr_TimePeriodNext.tv_nsec);
    }
    else
    {
        sprintf(retval, "(null)");
    }

    return( retval );
}

/**
 * Get the string version of a rk_resource_set_t value.
 *
 * @param rs The rk_resource_set_t to stringify or NULL.
 * @return A statically allocated string formatted with the values in the
 *         parameter.
 */
static char *rk_resource_set_string(rk_resource_set_t rs)
{
    static char retval[1024];

    if( (rs != NULL) && rk_resource_set_valid(rs) )
    {
        sprintf(retval,
                "[rs_Name=%s"
                "; rs_ProcessID=%d"
                "; rs_CPU=%s]",
                rs->rs_Name,
                rs->rs_ProcessID,
                cpu_reserve_string(rs->rs_CPU));
    }
    else
    {
        sprintf(retval, "(null)");
    }

    return( retval );
}

/**
 * Get the string version of a simulated pid_t value.
 *
 * @param pid The simulated pid_t to stringify.
 * @return A statically allocated string formatted with the values in the
 *         parameter.
 */
static char *rk_stub_pcb_string(pid_t pid)
{
    static char retval[1024];

    if( (pid >= 0) && (pid <= MAX_PCB) )
    {
        if( rk_stub_data.sd_PCBs[pid].p_Flags & PCBF_IN_USE )
        {
            struct rk_stub_pcb *sp = &rk_stub_data.sd_PCBs[pid];
            
            sprintf(retval,
                    "[p_Name=%s"
                    "; p_Flags=%lx"
                    "; p_Data=%p"
                    "; p_Precall=%p"
                    "; p_Postcall=%p]",
                    sp->p_Name,
                    sp->p_Flags,
                    sp->p_Data,
                    sp->p_Precall,
                    sp->p_Postcall);
        }
        else
        {
            sprintf(retval, "(stale:%d)", pid);
        }
    }
    else
    {
        sprintf(retval, "(invalid:%d)", pid);
    }

    return( retval );
}

/* END object -> string functions **/

/* BEGIN rk functions **/

/*
 * The majority of these functions are pretty straightforward.  They follow the
 * general form of:
 *
 *   - Validate inputs
 *   - Perform function
 *   - Handle resulting errors, if any
 */

void rk_inherit_mode(int dummy)
{
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%d)\n", __PRETTY_FUNCTION__, dummy);
    
    fprintf(rk_stub_data.sd_LogFile, "END %s\n", __PRETTY_FUNCTION__);
}

int rk_resource_sets_get_list(rk_resource_set_t *rs_inout, int count)
{
    int retval = 0;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);

    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p, %d)\n", __PRETTY_FUNCTION__, rs_inout, count);
    
    if( (rs_inout == NULL) || (count < 0) )
    {
        errno = EINVAL;
    }
    else if( count == 0 )
    {
    }
    else
    {
        struct rk_resource_set *rs;
        int lpc;
        
        rs = (struct rk_resource_set *)rk_stub_data.sd_ResourceSets.lh_Head;
        for( retval = 0;
             (rs->rs_Link.ln_Succ != NULL) && (retval < count);
             retval++, rs = (struct rk_resource_set *)rs->rs_Link.ln_Succ)
        {
            rs_inout[retval] = rs;
        }
        for( lpc = retval; lpc < count; lpc++ )
        {
            rs_inout[retval] = NULL;
        }
    }

    fprintf(rk_stub_data.sd_LogFile, "END %d = %s\n", retval, __PRETTY_FUNCTION__);
    
    return( retval );
}

int rk_resource_sets_get_num(void)
{
    struct rk_resource_set *rs;
    int retval = 0;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);

    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s()\n", __PRETTY_FUNCTION__);
    
    rs = (struct rk_resource_set *)rk_stub_data.sd_ResourceSets.lh_Head;
    for( retval = 0;
         (rs->rs_Link.ln_Succ != NULL);
         retval++, rs = (struct rk_resource_set *)rs->rs_Link.ln_Succ)
    {
        /* empty... */
    }

    fprintf(rk_stub_data.sd_LogFile, "END %d = %s\n", retval, __PRETTY_FUNCTION__);
    
    return( retval );
}

rk_resource_set_t rk_resource_set_create(const char *name)
{
    rk_resource_set_t retval = NULL_RESOURCE_SET;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);

    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%s)\n", __PRETTY_FUNCTION__, name);

    /* XXX Is the name exclusive? */
    if( name == NULL )
    {
        errno = EINVAL;
    }
    else if( strlen(name) == 0 )
    {
        errno = EINVAL;
    }
    else if( strlen(name) >= RSET_NAME_LEN )
    {
        errno = ENAMETOOLONG;
    }
    else if( !rk_name_valid(name) )
    {
        errno = EINVAL;
    }
    else if( (retval = calloc(1, sizeof(struct rk_resource_set))) != NULL )
    {
        lnAddTail(&rk_stub_data.sd_ResourceSets, &retval->rs_Link);
        strncpy(retval->rs_Name, name, RSET_NAME_LEN);
        retval->rs_ProcessID = -1;

        ensure(strlen(retval->rs_Name) > 0);
        ensure(strlen(retval->rs_Name) < RSET_NAME_LEN);
        ensure(strcmp(retval->rs_Name, name) == 0);
        ensure(rk_resource_set_valid(retval));
    }
    else
    {
        errno = ENOMEM;
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %p = %s\n", retval, __PRETTY_FUNCTION__);
    
    return( retval );
}

int rk_resource_set_destroy(rk_resource_set_t rs)
{
    int retval = -1;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs));
    
    if( rs == NULL )
    {
        errno = EINVAL;
    }
    else if( rk_resource_set_valid(rs) )
    {
        rk_cpu_reserve_delete(rs);

        if( rs->rs_ProcessID != -1 )
        {
            rk_stub_data.sd_PCBs[rs->rs_ProcessID].p_Resources = NULL;
            rs->rs_ProcessID = -1;
        }
        lnRemove(&rs->rs_Link);
        free(rs);
        retval = 0;
        
        ensure(!rk_resource_set_valid(rs));
    }
    
    fprintf(rk_stub_data.sd_LogFile, "%d END %s\n", retval, __PRETTY_FUNCTION__);

    return( retval );
}

int rk_resource_set_set_name(rk_resource_set_t rs, const char *name)
{
    int retval = -1;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s, %s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs), name);

    if( (rs == NULL) || (name == NULL) )
    {
        errno = EINVAL;
    }
    else if( !rk_resource_set_valid(rs) )
    {
        errno = EINVAL;
    }
    else if( strlen(name) == 0 )
    {
        errno = EINVAL;
    }
    else if( strlen(name) >= RSET_NAME_LEN )
    {
        errno = ENAMETOOLONG;
    }
    else if( !rk_name_valid(name) )
    {
        errno = EINVAL;
    }
    else
    {
        strncpy(rs->rs_Name, name, RSET_NAME_LEN);
        retval = 0;

        ensure(strlen(rs->rs_Name) > 0);
        ensure(strlen(rs->rs_Name) < RSET_NAME_LEN);
        ensure(strcmp(rs->rs_Name, name) == 0);
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %d = %s\n", retval, __PRETTY_FUNCTION__);

    return( retval );
}

int rk_resource_set_get_name(rk_resource_set_t rs, char *name_out)
{
    int retval = -1;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s, %p)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs), name_out);

    if( (rs == NULL) || (name_out == NULL) )
    {
        errno = EINVAL;
    }
    else if( !rk_resource_set_valid(rs) )
    {
        name_out[0] = '\0';
        errno = EINVAL;
    }
    else
    {
        strcpy(name_out, rs->rs_Name);
        retval = 0;
        
        ensure(strlen(name_out) > 0);
        ensure(strlen(name_out) < RSET_NAME_LEN);
        ensure(strcmp(rs->rs_Name, name_out) == 0);
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %d = %s name_out=%s\n", retval, __PRETTY_FUNCTION__, name_out);

    return( retval );
}

rk_reserve_t rk_resource_set_get_cpu_rsv(rk_resource_set_t rs)
{
    rk_reserve_t retval = NULL_RESERVE;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs));
    
    if( rs == NULL )
    {
        errno = EINVAL;
    }
    else if( !rk_resource_set_valid(rs) )
    {
        errno = EINVAL;
    }
    else if( rs->rs_CPU == NULL )
    {
        errno = ENOTCONN;
    }
    else
    {
        retval = (rk_reserve_t)rs->rs_CPU;

        ensure(cpu_reserve_valid(retval));
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %p = %s\n", retval, __PRETTY_FUNCTION__);

    return( retval );
}

int rk_resource_set_attach_process(rk_resource_set_t rs, pid_t pid)
{
    int retval = -1;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s, %d%s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs), pid, rk_stub_pcb_string(pid));
    
    if( (rs == NULL) || (pid < 0) )
    {
        errno = EINVAL;
    }
    else if( !rk_resource_set_valid(rs) )
    {
        errno = EINVAL;
    }
    else if( (rk_stub_data.sd_Mode >= RK_STUB_SIM) &&
             ((pid >= MAX_PCB) ||
              !(rk_stub_data.sd_PCBs[pid].p_Flags & PCBF_IN_USE)) )
    {
        errno = ESRCH;
    }
    else if( rs->rs_ProcessID == -1 )
    {
        rs->rs_ProcessID = pid;
        if( rk_stub_data.sd_Mode >= RK_STUB_SIM )
        {
            rk_stub_data.sd_PCBs[pid].p_Resources = rs;
            
            ensure(rk_proc_get_rset(pid) == rs);
        }
        retval = 0;
    }
    else
    {
        errno = ENOSYS; // XXX only one attach allowed at the moment.
    }

    fprintf(rk_stub_data.sd_LogFile, "END %d = %s\n", retval, __PRETTY_FUNCTION__);
    
    return( retval );
}

int rk_resource_set_detach_process(rk_resource_set_t rs, pid_t pid)
{
    int retval = -1;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s, %d%s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs), pid, rk_stub_pcb_string(pid));
    
    if( (rs == NULL) || (pid < 0) || (pid >= MAX_PCB) )
    {
        errno = EINVAL;
    }
    else if( !rk_resource_set_valid(rs) )
    {
        errno = EINVAL;
    }
    else if( !(rk_stub_data.sd_PCBs[pid].p_Flags & PCBF_IN_USE) )
    {
        errno = ESRCH;
    }
    else if( rs->rs_ProcessID == pid )
    {
        rk_stub_data.sd_PCBs[pid].p_Resources = NULL;
        rs->rs_ProcessID = -1;
        retval = 0;
        
        ensure(rk_proc_get_rset(pid) == NULL);
    }
    else
    {
        errno = EINVAL;
    }

    fprintf(rk_stub_data.sd_LogFile, "END %d = %s\n", retval, __PRETTY_FUNCTION__);
    
    return( retval );
}

int rk_resource_set_get_num_procs(rk_resource_set_t rs)
{
    int retval = -1;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);

    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs));
    
    if( rs == NULL_RESOURCE_SET )
    {
        errno = EINVAL;
    }
    else
    {
        if( rs->rs_ProcessID != -1 )
        {
            retval = 1;
        }
        else
        {
            retval = 0;
        }
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %d = %s\n", retval, __PRETTY_FUNCTION__);
    
    return( retval );
}

int rk_resource_set_get_proclist(rk_resource_set_t rs,
                                 pid_t *procs_inout,
                                 int count)
{
    int retval = -1;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);

    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s, %p, %d)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs), procs_inout, count);
    
    if( (rs == NULL_RESOURCE_SET) || (procs_inout == NULL) || (count < 0) )
    {
        errno = EINVAL;
    }
    else if( count == 0 )
    {
        retval = 0;
    }
    else
    {
        int lpc;

        if( rs->rs_ProcessID != -1 )
        {
            retval = 0;
        }
        procs_inout[0] = rs->rs_ProcessID;
        for( lpc = 1; lpc < count; lpc++ )
        {
            procs_inout[lpc] = -1;
        }
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %d = %s\n", retval, __PRETTY_FUNCTION__);
    
    return( retval );
}

rk_resource_set_t rk_proc_get_rset(pid_t pid)
{
    rk_resource_set_t retval = NULL_RESOURCE_SET;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%d%s)\n", __PRETTY_FUNCTION__, pid, rk_stub_pcb_string(pid));
    
    if( (pid < 0) || (pid >= MAX_PCB) )
    {
        errno = EINVAL;
    }
    else if( !(rk_stub_data.sd_PCBs[pid].p_Flags & PCBF_IN_USE) )
    {
        errno = ESRCH;
    }
    else if( rk_stub_data.sd_PCBs[pid].p_Resources == NULL )
    {
        errno = ENOTCONN;
    }
    else
    {
        retval = rk_stub_data.sd_PCBs[pid].p_Resources;

        ensure(rk_resource_set_valid(retval));
    }

    fprintf(rk_stub_data.sd_LogFile, "END %p%s = %s\n", retval, rk_resource_set_string(retval), __PRETTY_FUNCTION__);
    
    return( retval );
}

int rk_cpu_reserve_create(rk_resource_set_t rs,
                          rk_reserve_t *r_out,
                          cpu_reserve_attr_t ra_in)
{
    cpu_reserve_t cr;
    int retval = -1;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s, %p, %p%s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs), r_out, ra_in, cpu_reserve_attr_string(ra_in));
    
    if( (rs == NULL) || (r_out == NULL) || (ra_in == NULL) )
    {
        errno = EINVAL;
    }
    else if( !rk_resource_set_valid(rs) )
    {
        errno = EINVAL;
    }
    else if( !rk_cpu_reserve_attr_valid(ra_in) )
    {
        errno = EINVAL;
    }
    else if( (rs->rs_CPU != NULL) )
    {
        errno = EISCONN;
    }
    else if( (cr = calloc(1, sizeof(struct cpu_reserve))) != NULL )
    {
        int lpc;
        
        *r_out = NULL;
        rs->rs_CPU = cr;
        cr->cr_Attributes = *((cpu_reserve_attr_t)ra_in);
        switch( rk_stub_data.sd_Mode )
        {
        case RK_STUB_LOG:
            retval = 0;
            break;
        case RK_STUB_SIM:
            cr->cr_Compute.cr_DataPeriodStart = rk_stub_data.sd_CurrentTime;
            cr->cr_Compute.cr_DataPeriodEnd = rk_stub_data.sd_CurrentTime;
            cr->cr_Compute.cr_DataPeriodNext = rk_stub_data.sd_CurrentTime;
            cr->cr_Compute.cr_TimePeriodStart = rk_stub_data.sd_CurrentTime;
            cr->cr_Compute.cr_TimePeriodEnd = rk_stub_data.sd_CurrentTime;
            cr->cr_Compute.cr_TimePeriodNext = rk_stub_data.sd_CurrentTime;
            /* Open the trace files... */
            retval = 0;
            for( lpc = 0; (lpc < RK_CPU_TRACE_MAX) && (retval == 0); lpc++ )
            {
                char trace_name[RSET_NAME_LEN + 64];
                
                snprintf(trace_name, sizeof(trace_name),
                         "%s_cpu_%s",
                         rs->rs_Name,
                         rk_cpu_trace_names[lpc]);
                if( (cr->cr_Trace[lpc] = fopen(trace_name, "w")) != NULL )
                {
                    fprintf(cr->cr_Trace[lpc], "0 0.0\n");
                }
                else
                {
                    retval = -1; /* errno is set by fopen. */
                }
                
                ensure(strlen(trace_name) < sizeof(trace_name));
            }
            if( retval == 0 )
            {
                char times_name[RSET_NAME_LEN + 64];
                FILE *times_file;

                /* Parse the input file... */
                snprintf(times_name, sizeof(times_name),
                         "%s_cpu_times",
                         rs->rs_Name);
                if( (times_file = fopen(times_name, "r")) != NULL )
                {
                    long long deadline_us;
                    int done = 0;
                    
                    deadline_us = timespec_to_microsec(&ra_in->deadline);
                    cr->cr_Compute.cr_Length = 1;
                    while( !done && (retval == 0) )
                    {
                        struct timespec *ts;
                        
                        if( (ts = realloc(cr->cr_Compute.cr_Times,
                                          cr->cr_Compute.cr_Length *
                                          sizeof(struct timespec)))
                            != NULL )
                        {
                            float percent;
                            
                            cr->cr_Compute.cr_Times = ts;
                            if( (fscanf(times_file, "%f", &percent) == 1) &&
                                (percent >= 0.0) && (percent <= 120.0) )
                            {
                                long long compute_us;

                                /*
                                 * Compute the needed compute time from the
                                 * percentage required as specified by the
                                 * file and the deadline as specified by
                                 * ra_in.
                                 */
                                compute_us = (long long)
                                    (((double)deadline_us) *
                                     (percent / 100.0));
                                cr->cr_Compute.
                                    cr_Times[cr->cr_Compute.cr_TimeIndex] =
                                    microsec_to_timespec(compute_us);
                                cr->cr_Compute.cr_TimeIndex += 1;
                                cr->cr_Compute.cr_Length += 1;
                            }
                            else if( feof(times_file) )
                            {
                                /* No more inputs. */
                                cr->cr_Compute.cr_DataPeriodRemaining =
                                    cr->cr_Compute.cr_Times[0];
                                cr->cr_Compute.cr_Length -= 1;
                                cr->cr_Compute.cr_TimeIndex = -1;
                                done = 1;
                            }
                            else
                            {
                                /* Bad data. */
#if defined(EFTYPE)
                                errno = EFTYPE;
#else
                                errno = EINVAL;
#endif
                                retval = -1;
                            }
                        }
                        else
                        {
                            errno = ENOMEM;
                            retval = -1;
                        }
                    }
                    if( cr->cr_Compute.cr_Length != 0 )
                    {
                        /* Found some valid data. */
                    }
                    else
                    {
                        /* No inputs... */
#if defined(EFTYPE)
                        errno = EFTYPE;
#else
                        errno = EINVAL;
#endif
                        retval = -1;
                    }
                    fclose(times_file);
                }
                else
                {
                    retval = -1; /* errno is set by fopen. */
                }

                ensure(strlen(times_name) < sizeof(times_name));
            }
            break;
        default:
            break;
        }
        if( retval == 0 )
        {
            *r_out = cr;
        }
        else
        {
            rk_cpu_reserve_delete(rs);
        }
        
        ensure((*r_out == NULL) || cpu_reserve_valid(*r_out));
    }
    else
    {
        errno = ENOMEM;
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %d = %s r_out=%s\n", retval, __PRETTY_FUNCTION__, r_out == NULL ? "(null)" : cpu_reserve_string(*r_out));

    return( retval );
}

int rk_cpu_reserve_delete(rk_resource_set_t rs)
{
    int retval = -1;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs));
    
    if( rs == NULL )
    {
        errno = EINVAL;
    }
    else if( rs->rs_CPU == NULL )
    {
        errno = ENOTCONN;
    }
    else if( !rk_resource_set_valid(rs) )
    {
        errno = EINVAL;
    }
    else
    {
        cpu_reserve_t cr;
        int lpc;

        cr = rs->rs_CPU;
        free(cr->cr_Compute.cr_Times);
        cr->cr_Compute.cr_Times = NULL;
        /* Cleanup the trace files... */
        for( lpc = 0; lpc < RK_CPU_TRACE_MAX; lpc++ )
        {
            /*
             * Check for NULLs since this function will be called if
             * rk_cpu_reserve_create() fails to open a trace file.
             */
            if( cr->cr_Trace[lpc] != NULL )
            {
                fclose(cr->cr_Trace[lpc]);
                cr->cr_Trace[lpc] = NULL;
            }
        }
        free(rs->rs_CPU);
        rs->rs_CPU = NULL;
        retval = 0;

        ensure(!cpu_reserve_valid(cr));
    }
    
    fprintf(rk_stub_data.sd_LogFile, "%d END %s\n", retval, __PRETTY_FUNCTION__);

    return( retval );
}

int rk_cpu_reserve_get_attr(rk_reserve_t cr, cpu_reserve_attr_t ra_out)
{
    int retval = -1;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s, %p)\n", __PRETTY_FUNCTION__, cr, cpu_reserve_string((cpu_reserve_t)cr), ra_out);
    
    if( (cr == NULL) || (ra_out == NULL) )
    {
        errno = EINVAL;
    }
    else if( !cpu_reserve_valid(cr) )
    {
        errno = EINVAL;
    }
    else
    {
        *ra_out = ((cpu_reserve_t)cr)->cr_Attributes;
        retval = 0;
        
        ensure(rk_cpu_reserve_attr_valid(ra_out));
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %d = %s ra_out=%p%s\n", retval, __PRETTY_FUNCTION__, ra_out, cpu_reserve_attr_string(ra_out));
    
    return( retval );
}

int rk_cpu_reserve_ctl(rk_resource_set_t rs, cpu_reserve_attr_t ra_in)
{
    int retval = -1;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);
    
    fprintf(rk_stub_data.sd_LogFile, "BEGIN %s(%p%s, %p%s)\n", __PRETTY_FUNCTION__, rs, rk_resource_set_string(rs), ra_in, cpu_reserve_attr_string(ra_in));
    
    if( (rs == NULL) || (ra_in == NULL) )
    {
        errno = EINVAL;
    }
    else if( !rk_resource_set_valid(rs) )
    {
        errno = EINVAL;
    }
    else if( !rk_cpu_reserve_attr_valid(ra_in) )
    {
        errno = ENOSPC;
    }
    else if( rs->rs_CPU == NULL )
    {
        errno = ENOTCONN;
    }
    else
    {
        cpu_reserve_t cr;

        cr = rs->rs_CPU;
        /* XXX ick */
        if( (cr->cr_Flags & CRF_RUNNING) &&
            tscmp(&cr->cr_Compute.cr_TimePeriodEnd,
                  &rk_stub_data.sd_CurrentTime,
                  !=) &&
            tscmp(&cr->cr_Compute.cr_DataPeriodEnd,
                  &rk_stub_data.sd_CurrentTime,
                  !=) )
        {
            rk_cpu_reserve_tick(rs,
                                cr,
                                &rk_stub_data.sd_CurrentTime,
                                &rk_stub_data.sd_NextTime,
                                &ra_in->compute_time);
            if( !(rk_stub_data.sd_Flags & SDF_IN_TICK) )
            {
                rk_stub_data.sd_CurrentTime = rk_stub_data.sd_NextTime;
            }
        }
        cr->cr_Attributes = *ra_in;
        retval = 0;
    }
    
    fprintf(rk_stub_data.sd_LogFile, "END %d = %s\n", retval, __PRETTY_FUNCTION__);
    
    return( retval );
}

int rk_clock_gettime(clockid_t clock_id, struct timespec *ts)
{
    int retval = -1;

    if( clock_id != CLOCK_REALTIME )
    {
        errno = EINVAL;
    }
    else if( ts == NULL )
    {
        errno = EINVAL;
    }
    else
    {
        *ts = rk_stub_data.sd_CurrentTime;
        retval = 0;
    }
    return( retval );
}

int rk_clock_settime(clockid_t clock_id, struct timespec *ts)
{
    int retval = -1;
    
    if( clock_id != CLOCK_REALTIME )
    {
        errno = EINVAL;
    }
    else if( ts == NULL )
    {
        errno = EINVAL;
    }
    else
    {
        rk_stub_data.sd_CurrentTime = *ts;
        retval = 0;
    }
    return( retval );
}

int rk_clock_getres(clockid_t clock_id, struct timespec *ts)
{
    int retval = -1;
    
    if( clock_id != CLOCK_REALTIME )
    {
        errno = EINVAL;
    }
    else if( ts == NULL )
    {
        errno = EINVAL;
    }
    else
    {
        ts->tv_sec = 0;
        ts->tv_nsec = NANOS_PER_MICRO;
        retval = 0;
    }
    return( retval );
}

/* END rk functions **/

/* BEGIN rk_stub functions **/

void rk_stub_set_mode(rk_stub_mode_t mode)
{
    require(mode > RK_STUB_MIN);
    require(mode < RK_STUB_MAX);

    require(rk_stub_data.sd_Mode == RK_STUB_MIN);

    rk_stub_data.sd_Mode = mode;

    lnNewList(&rk_stub_data.sd_ResourceSets);
    if( (rk_stub_data.sd_LogFile = fopen("rk.log", "w")) == NULL )
    {
        perror("Cannot open log file.");
        exit(EXIT_FAILURE);
    }
    setvbuf(rk_stub_data.sd_LogFile, NULL, _IONBF, 0);
}

/**
 * Verify time values and update the next time value if an earlier time is
 * seen.
 *
 * @param next The next simulated time value.
 * @param curr The current time.
 * @param new_next An event time.
 */
static
void rk_next_tick(struct timespec *next,
                  struct timespec *curr,
                  struct timespec *new_next)
{
    require(next != NULL);
    require(curr != NULL);
    require(new_next != NULL);

    if( ((int)new_next->tv_nsec) < 0 )
    {
        require(0);
    }
    if( tscmp(curr, new_next, ==) )
    {
        /* Ignore */
    }
    else if( tscmp(new_next, next, <) )
    {
        *next = *new_next;
    }
}

static
void rk_cpu_reserve_tick(rk_resource_set_t rs,
                         cpu_reserve_t cr,
                         struct timespec *curr,
                         struct timespec *next,
                         struct timespec *new_compute)
{
    long long time_period_start_us, time_period_end_us, time_period_next_us;
    long long data_period_start_us, data_period_end_us, data_period_next_us;
    long long curr_us, given_compute_us, given_period_us, given_deadline_us;
    long long needed_compute_us, data_period_remaining_us;
    float given_cpu_percent, needed_cpu_percent;
    struct rk_stub_pcb *proc;
    
    require(rs != NULL);
    require(cr != NULL);
    require(curr != NULL);
    require(next != NULL);

    proc = &rk_stub_data.sd_PCBs[rs->rs_ProcessID];

    fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
            "# tick %p %d.%ld  rem %d.%ld\n",
            rs,
            (int)curr->tv_sec,
            curr->tv_nsec,
            (int)cr->cr_Compute.cr_DataPeriodRemaining.tv_sec,
            cr->cr_Compute.cr_DataPeriodRemaining.tv_nsec);

    curr_us = timespec_to_microsec(curr);
    
    given_compute_us = timespec_to_microsec(&cr->cr_Attributes.compute_time);
    given_period_us = timespec_to_microsec(&cr->cr_Attributes.period);
    given_deadline_us = timespec_to_microsec(&cr->cr_Attributes.deadline);

    given_cpu_percent = (((float)given_compute_us) /
                         ((float)given_deadline_us));

    needed_compute_us = timespec_to_microsec(
        &cr->cr_Compute.cr_Times[(cr->cr_Compute.cr_DataIndex) %
                                (cr->cr_Compute.cr_Length)]);
    
    time_period_start_us =
        timespec_to_microsec(&cr->cr_Compute.cr_TimePeriodStart);
    time_period_end_us =
        timespec_to_microsec(&cr->cr_Compute.cr_TimePeriodEnd);
    time_period_next_us =
        timespec_to_microsec(&cr->cr_Compute.cr_TimePeriodNext);
    data_period_start_us =
        timespec_to_microsec(&cr->cr_Compute.cr_DataPeriodStart);
    data_period_end_us =
        timespec_to_microsec(&cr->cr_Compute.cr_DataPeriodEnd);
    data_period_next_us =
        timespec_to_microsec(&cr->cr_Compute.cr_DataPeriodNext);
    data_period_remaining_us =
        timespec_to_microsec(&cr->cr_Compute.cr_DataPeriodRemaining);
 
    needed_cpu_percent = (((float)data_period_remaining_us) /
                          ((float)given_deadline_us));
    
    if( cr->cr_Flags & CRF_RUNNING )
    {
        if( curr_us == data_period_end_us )
        {
            struct timeval tv;
            
            if( cr->cr_Compute.cr_DataIndex == cr->cr_Compute.cr_TimeIndex )
            {
                cr->cr_Flags &= ~CRF_RUNNING;
                
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                        "# line %d\n"
                        "%qd 0\n",
                        __LINE__,
                        curr_us / 1000);
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                        "# line %d\n"
                        "%qd 0\n",
                        __LINE__,
                        curr_us / 1000);
            }
            else
            {
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                        "# line %d next %d.%ld ind %d %d\n"
                        "%qd %f\n"
                        "%qd 0\n",
                        __LINE__,
                        (int)cr->cr_Compute.cr_DataPeriodNext.tv_sec,
                        cr->cr_Compute.cr_DataPeriodNext.tv_nsec,
                        cr->cr_Compute.cr_DataIndex + 1,
                        cr->cr_Compute.cr_TimeIndex,
                        (curr_us / 1000) - 1,
                        given_cpu_percent * 100.0,
                        curr_us / 1000);
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                        "# line %d\n"
                        "%qd 0\n",
                        __LINE__,
                        curr_us / 1000);
            }

            tv.tv_sec = timespec_to_microsec(
                &cr->cr_Compute.cr_Times[(cr->cr_Compute.cr_DataIndex) %
                                        (cr->cr_Compute.cr_Length)]) / 1000000;
            tv.tv_usec = timespec_to_microsec(
                &cr->cr_Compute.cr_Times[(cr->cr_Compute.cr_DataIndex) %
                                        (cr->cr_Compute.cr_Length)]) % 1000000;
            timeradd(&proc->p_Usage.ru_utime, &tv, &proc->p_Usage.ru_utime);
            proc->p_Postcall(rk_stub_data.sd_PCBs[rs->rs_ProcessID].p_Data);
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPLETE],
                    "# %d\n"
                    "%qd -5\n",
                    cr->cr_Compute.cr_DataIndex,
                    curr_us / 1000);
            cr->cr_Compute.cr_DataIndex += 1;

            cr->cr_Compute.cr_DataPeriodRemaining =
                cr->cr_Compute.cr_Times[(cr->cr_Compute.cr_DataIndex) %
                                       (cr->cr_Compute.cr_Length)];
            
            if( cr->cr_Flags & CRF_RUNNING )
            {
                /* Recompute */
                needed_compute_us = timespec_to_microsec(
                        &cr->cr_Compute.
                        cr_Times[(cr->cr_Compute.cr_DataIndex) %
                                (cr->cr_Compute.cr_Length)]);
    
                needed_cpu_percent = (((float)needed_compute_us) /
                                      ((float)given_deadline_us));
            }
        }
        if( curr_us == time_period_end_us )
        {
            if( cr->cr_Compute.cr_DataIndex == cr->cr_Compute.cr_TimeIndex )
            {
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                        "# line %d\n"
                        "%qd 0\n",
                        __LINE__,
                        curr_us / 1000);
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                        "# line %d\n"
                        "%qd 0\n",
                        __LINE__,
                        curr_us / 1000);
            }
        }
    }
    if( curr_us == time_period_end_us )
    {
        fprintf(cr->cr_Trace[RK_CPU_TRACE_DEADLINE],
                "# line %d\n"
                "%qd 120\n",
                __LINE__,
                curr_us / 1000);
        if( (cr->cr_Flags & CRF_RUNNING) &&
            (cr->cr_Compute.cr_DataIndex < cr->cr_Compute.cr_TimeIndex) )
        {
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# line %d\n"
                    "%qd 0\n",
                    __LINE__,
                    curr_us / 1000);
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                    "# line %d\n"
                    "%qd 0\n",
                    __LINE__,
                    curr_us / 1000);
        }
        if( (cr->cr_Flags & CRF_RUNNING) && (curr_us != data_period_end_us) )
        {
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# line %d  %qd -= %qd max(%qd, %qd) * %f\n",
                    __LINE__,
                    data_period_remaining_us,
                    curr_us,
                    time_period_start_us,
                    data_period_start_us,
                    given_cpu_percent);
            data_period_remaining_us -=
                (curr_us - max(time_period_start_us, data_period_start_us)) *
                given_cpu_percent;
            if( data_period_remaining_us < 0 )
            {
                data_period_remaining_us = 0;
            }
            cr->cr_Compute.cr_DataPeriodRemaining =
                microsec_to_timespec(data_period_remaining_us);
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# sub line %d %d.%ld\n",
                    __LINE__,
                    (int)cr->cr_Compute.cr_DataPeriodRemaining.tv_sec,
                    cr->cr_Compute.cr_DataPeriodRemaining.tv_nsec);
        }
        
        cr->cr_Flags &= ~CRF_RUNNING;

        cr->cr_Compute.cr_TimeIndex += 1;
    }

    if( curr_us == time_period_next_us )
    {
        long long realtime_compute_us;
        float realtime_cpu_percent;
        
        cr->cr_Flags |= CRF_RUNNING;

        realtime_compute_us = timespec_to_microsec(
                &cr->cr_Compute.cr_Times[(cr->cr_Compute.cr_TimeIndex) %
                                        (cr->cr_Compute.cr_Length)]);
        
        realtime_cpu_percent = (((float)realtime_compute_us) /
                                ((float)given_deadline_us));
        
        fprintf(cr->cr_Trace[RK_CPU_TRACE_PERIOD],
                "# line %d\n"
                "%qd 120\n",
                __LINE__,
                curr_us / 1000);
        fprintf(cr->cr_Trace[RK_CPU_TRACE_REALTIME],
                "# line %d\n"
                "%qd %f\n"
                "%qd 0\n",
                __LINE__,
                curr_us / 1000,
                realtime_cpu_percent * 100.0,
                (curr_us + given_deadline_us) / 1000);
        if( cr->cr_Compute.cr_DataIndex < cr->cr_Compute.cr_TimeIndex )
        {
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# line %d\n"
                    "%qd %f\n",
                    __LINE__,
                    curr_us / 1000,
                    given_cpu_percent * 100.0);
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                    "# line %d\n"
                    "%qd 0\n",
                    __LINE__,
                    curr_us / 1000);
        }
        
        cr->cr_Compute.cr_TimePeriodStart = *curr;
        cr->cr_Compute.cr_TimePeriodEnd = microsec_to_timespec(
            curr_us + given_deadline_us);
        cr->cr_Compute.cr_TimePeriodNext =
            microsec_to_timespec(time_period_next_us + given_period_us);
    }

    if( (curr_us == data_period_next_us) || (new_compute != NULL) )
    {
        float period_used, needed_periods, floored_periods;
        
        if( new_compute == NULL )
        {
            rk_stub_precall_t precall;

            precall = rk_stub_data.sd_PCBs[rs->rs_ProcessID].p_Precall;
            if( precall != NULL )
            {
                void *proc_data;

                proc_data = rk_stub_data.sd_PCBs[rs->rs_ProcessID].p_Data;
                while( (cr->cr_Compute.cr_DataIndex <=
                        cr->cr_Compute.cr_TimeIndex) &&
                       (precall(proc_data) == RKSP_DROP) )
                {
                    fprintf(cr->cr_Trace[RK_CPU_TRACE_DROP],
                            "# line %d\n"
                            "%qd -2\n",
                            __LINE__,
                            curr_us / 1000);
                    cr->cr_Compute.cr_DataIndex += 1;
                }
                if( cr->cr_Compute.cr_DataIndex <=
                    cr->cr_Compute.cr_TimeIndex )
                {
                    cr->cr_Compute.cr_DataPeriodRemaining =
                        cr->cr_Compute.cr_Times[(cr->cr_Compute.cr_DataIndex) %
                                               (cr->cr_Compute.cr_Length)];
                    /* Recompute */
                    needed_compute_us = timespec_to_microsec(
                        &cr->cr_Compute.
                        cr_Times[(cr->cr_Compute.cr_DataIndex) %
                                (cr->cr_Compute.cr_Length)]);
                    needed_cpu_percent = (((float)needed_compute_us) /
                                          ((float)given_deadline_us));
                }
                else
                {
                    cr->cr_Flags &= ~CRF_RUNNING;
                    
                    cr->cr_Compute.cr_DataPeriodNext =
                        cr->cr_Compute.cr_TimePeriodNext;
                    goto reeval;
                }
            }
        }
        else
        {
            data_period_remaining_us =
                timespec_to_microsec(&cr->cr_Compute.cr_DataPeriodRemaining);
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# line %d  %qd -= %qd - max(%qd, %qd) * %f\n",
                    __LINE__,
                    data_period_remaining_us,
                    curr_us,
                    time_period_start_us,
                    data_period_start_us,
                    given_cpu_percent);
            data_period_remaining_us -=
                (curr_us - max(time_period_start_us, data_period_start_us)) *
                given_cpu_percent;
            cr->cr_Compute.cr_DataPeriodRemaining =
                microsec_to_timespec(data_period_remaining_us);
            needed_cpu_percent = (((float)data_period_remaining_us) /
                                  ((float)given_deadline_us));
        }
        
        if( new_compute == NULL )
        {
            given_compute_us =
                timespec_to_microsec(&cr->cr_Attributes.compute_time);
        }
        else
        {
            given_compute_us = timespec_to_microsec(new_compute);
        }
        given_period_us = timespec_to_microsec(&cr->cr_Attributes.period);
        given_deadline_us = timespec_to_microsec(&cr->cr_Attributes.deadline);

        given_cpu_percent = (((float)given_compute_us) /
                             ((float)given_deadline_us));

        if( given_cpu_percent == 0.0 )
        {
            cr->cr_Compute.cr_DataPeriodEnd = (struct timespec){
                LONG_MAX,
                LONG_MAX
            };
            cr->cr_Compute.cr_DataPeriodNext = (struct timespec){
                LONG_MAX,
                LONG_MAX
            };
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                    "# line %d\n"
                    "%qd 0\n",
                    __LINE__,
                    curr_us / 1000);
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# line %d\n"
                    "%qd 0\n",
                    __LINE__,
                    curr_us / 1000);
            return;
        }
        
        time_period_start_us =
            timespec_to_microsec(&cr->cr_Compute.cr_TimePeriodStart);
        period_used = (((float)(curr_us - time_period_start_us)) /
                       ((float)given_deadline_us));
        fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                "# line %d  %f + %f / %f\n",
                __LINE__,
                period_used,
                needed_cpu_percent,
                given_cpu_percent);
        if( needed_cpu_percent == 0.0 )
        {
            needed_periods = 0.0;
            floored_periods = 0.0;
            cr->cr_Compute.cr_DataPeriodEnd = *curr;
            cr->cr_Compute.cr_DataPeriodEnd.tv_nsec += NANOS_PER_MICRO;
        }
        else
        {
            needed_periods = period_used +
                (needed_cpu_percent / given_cpu_percent);
            floored_periods = floorf(needed_periods);
            if( needed_periods == floored_periods )
            {
                floored_periods -= 1.0;
            }
            cr->cr_Compute.cr_DataPeriodStart = *curr;
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# line %d  %d.%ld\n",
                    __LINE__,
                    (int)cr->cr_Compute.cr_DataPeriodStart.tv_sec,
                    cr->cr_Compute.cr_DataPeriodStart.tv_nsec);
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# line %d  %qd + (%qd * %f) + (%qd * (%f - %f))\n",
                    __LINE__,
                    time_period_start_us,
                    given_period_us,
                    floored_periods,
                    given_deadline_us,
                    needed_periods,
                    floored_periods);
            cr->cr_Compute.cr_DataPeriodEnd = microsec_to_timespec(
                time_period_start_us +
                (given_period_us * floored_periods) +
                (given_deadline_us * (needed_periods - floored_periods)));
        }

        if( needed_periods <= 1.0 )
        {
            if( needed_periods == 1.0 )
            {
                /* XXX ick */
                cr->cr_Compute.cr_DataPeriodEnd =
                    cr->cr_Compute.cr_TimePeriodEnd;
            }
            if( cr->cr_Compute.cr_DataIndex == cr->cr_Compute.cr_TimeIndex )
            {
                cr->cr_Compute.cr_DataPeriodNext =
                    cr->cr_Compute.cr_TimePeriodNext;
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                        "# line %d end %d.%ld\n"
                        "%qd %f\n",
                        __LINE__,
                        (int)cr->cr_Compute.cr_DataPeriodEnd.tv_sec,
                        cr->cr_Compute.cr_DataPeriodEnd.tv_nsec,
                        curr_us / 1000,
                        given_cpu_percent * 100.0);
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                        "# line %d\n"
                        "%qd 0\n",
                        __LINE__,
                        curr_us / 1000);
            }
            else
            {
                cr->cr_Compute.cr_DataPeriodNext =
                    cr->cr_Compute.cr_DataPeriodEnd;
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                        "# line %d end %d.%ld\n"
                        "%qd %f\n",
                        __LINE__,
                        (int)cr->cr_Compute.cr_DataPeriodEnd.tv_sec,
                        cr->cr_Compute.cr_DataPeriodEnd.tv_nsec,
                        curr_us / 1000,
                        given_cpu_percent * 100.0);
                fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                        "# line %d\n"
                        "%qd 0\n",
                        __LINE__,
                        curr_us / 1000);
            }
        }
        else if( !(cr->cr_Flags & CRF_RUNNING) )
        {
            cr->cr_Compute.cr_DataPeriodNext =
                cr->cr_Compute.cr_TimePeriodNext;
        }
        else
        {
            cr->cr_Compute.cr_DataPeriodNext = cr->cr_Compute.cr_DataPeriodEnd;
            
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
                    "# line %d\n"
                    "%qd %f\n",
                    __LINE__,
                    curr_us / 1000,
                    given_cpu_percent * 100.0);
            fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_SUCCESS],
                    "# line %d\n"
                    "%qd 0\n",
                    __LINE__,
                    curr_us / 1000);
        }
        
    }
    
 reeval:
    
    fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
            "# line %d\n"
            "# data end %d.%ld next %d.%ld\n"
            "# time end %d.%ld next %d.%ld\n",
            __LINE__,
            (int)cr->cr_Compute.cr_DataPeriodEnd.tv_sec,
            cr->cr_Compute.cr_DataPeriodEnd.tv_nsec,
            (int)cr->cr_Compute.cr_DataPeriodNext.tv_sec,
            cr->cr_Compute.cr_DataPeriodNext.tv_nsec,
            (int)cr->cr_Compute.cr_TimePeriodEnd.tv_sec,
            cr->cr_Compute.cr_TimePeriodEnd.tv_nsec,
            (int)cr->cr_Compute.cr_TimePeriodNext.tv_sec,
            cr->cr_Compute.cr_TimePeriodNext.tv_nsec);

    rk_next_tick(next, curr, &cr->cr_Compute.cr_TimePeriodEnd);
    rk_next_tick(next, curr, &cr->cr_Compute.cr_TimePeriodNext);
    if( cr->cr_Flags & CRF_RUNNING )
    {
        rk_next_tick(next, curr, &cr->cr_Compute.cr_DataPeriodEnd);
    }
    rk_next_tick(next, curr, &cr->cr_Compute.cr_DataPeriodNext);

    fprintf(cr->cr_Trace[RK_CPU_TRACE_COMPUTE_FAIL],
            "# line %d next %d.%ld\n",
            __LINE__,
            (int)next->tv_sec,
            next->tv_nsec);
    
    ensure(timespec_to_microsec(curr) < timespec_to_microsec(next));
}

void rk_stub_next_tick(void)
{
    rk_resource_set_t rs;
    
    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);

    rk_stub_data.sd_Flags |= SDF_IN_TICK;
    rk_stub_data.sd_CurrentTime = rk_stub_data.sd_NextTime;
    rk_stub_data.sd_NextTime.tv_sec = LONG_MAX;
    rk_stub_data.sd_NextTime.tv_nsec = LONG_MAX;
    /* Process all the resource sets. */
    rs = (rk_resource_set_t)rk_stub_data.sd_ResourceSets.lh_Head;
    while( rs->rs_Link.ln_Succ != NULL )
    {
        if( (rs->rs_CPU != NULL) && (rs->rs_ProcessID != -1) )
        {
            rk_cpu_reserve_tick(rs,
                                rs->rs_CPU,
                                &rk_stub_data.sd_CurrentTime,
                                &rk_stub_data.sd_NextTime,
                                NULL);
        }
        rs = (rk_resource_set_t)rs->rs_Link.ln_Succ;
    }
    rk_stub_data.sd_Flags &= ~SDF_IN_TICK;

    ensure(timespec_to_microsec(&rk_stub_data.sd_CurrentTime) <
           timespec_to_microsec(&rk_stub_data.sd_NextTime));
}

pid_t rk_stub_mk_pid(const char *name,
                     void *data,
                     rk_stub_precall_t precall,
                     rk_stub_postcall_t postcall)
{
    pid_t retval = -1;
    int lpc;

    require(rk_stub_data.sd_Mode > RK_STUB_MIN);
    require(rk_stub_data.sd_Mode < RK_STUB_MAX);

    require(name != NULL);

    /* Scan all PCBs looking for one that is not in use. */
    for( lpc = 0; (lpc < MAX_PCB) && (retval == -1); lpc++ )
    {
        if( !(rk_stub_data.sd_PCBs[lpc].p_Flags & PCBF_IN_USE) )
        {
            rk_stub_data.sd_PCBs[lpc].p_Name = name;
            rk_stub_data.sd_PCBs[lpc].p_Flags |= PCBF_IN_USE;
            rk_stub_data.sd_PCBs[lpc].p_Data = data;
            rk_stub_data.sd_PCBs[lpc].p_Precall = precall;
            rk_stub_data.sd_PCBs[lpc].p_Postcall = postcall;
            retval = lpc;
        }
    }
    if( retval == -1 )
    {
        errno = ENOMEM;
    }
    return( retval );
}

void rk_stub_getrusage(pid_t pid, struct rusage *ru)
{
    require(pid >= 0);
    require(pid < MAX_PCB);
    require(rk_stub_data.sd_PCBs[pid].p_Flags & PCBF_IN_USE);
    require(ru != NULL);

    *ru = rk_stub_data.sd_PCBs[pid].p_Usage;
}

/* END rk_stub functions **/

---