RealTimeSchedule.cc

Go to the documentation of this file.

/*
 * RealTimeSchedule.cc
 *
 * Copyright (c) 2003, 2004 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 RealTimeSchedule.cc
 *
 * Implementation of the RealTimeSchedule class.
 */

#include "config.h"

#include <assert_pp.h>

#include <iostream>

#include <time_util.h>

#include "RealTimeSchedule.hh"

#if !defined(min)
/**
 * @param x First comparable value.
 * @param y Second comparable value.
 * @return The minimum of x and y.
 */
#define min(x, y) ((x) < (y) ? (x) : (y))

/**
 * @param x First comparable value.
 * @param y Second comparable value.
 * @return The maximum of x and y.
 */
#define max(x, y) ((x) > (y) ? (x) : (y))
#endif

RealTimeSchedule::RealTimeSchedule(CORBA::ULong start,
                                   CORBA::ULong period,
                                   CORBA::ULong deadline,
                                   rts_reserve_mode_t reserve_mode,
                                   pid_t pid) :
    rts_Start(start),
    rts_Period(period),
    rts_Deadline(deadline),
    rts_ReserveMode(reserve_mode),
    rts_PID(pid)
{
    require(deadline <= period);
}

void RealTimeSchedule::setParameters(const Broker::ScheduleParameters &sp)
    throw (Broker::DuplicateScheduleParameter,
           Broker::InvalidScheduleParameter,
           Broker::MissingScheduleParameter)
{
    unsigned long long start = 0, period = ~0, deadline = ~0;
    unsigned int lpc;
    const char *str;
    pid_t pid = -1;

    for( lpc = 0; lpc < sp.length(); lpc++ )
    {
        if( strcasecmp(sp[lpc].name.in(), "reserve-mode") == 0 )
        {
            const char *str;

            if( sp[lpc].value >>= str )
            {
                if( strcasecmp(str, "soft") == 0 )
                {
                    this->rts_ReserveMode = RTS_RSV_SOFT;
                }
                else if( strcasecmp(str, "hard") == 0 )
                {
                    this->rts_ReserveMode = RTS_RSV_HARD;
                }
                else
                {
                    throw Broker::InvalidScheduleParameter(
                        "'reserve-mode' not 'hard' or 'soft'", sp[lpc]);
                }
            }
            else
            {
                throw Broker::InvalidScheduleParameter(
                        "'reserve-mode' not a string", sp[lpc]);
            }
        }
        else if( strcasecmp(sp[lpc].name.in(), "start") == 0 )
        {
            if( ((sp[lpc].value >>= str) && string_to_microsec(&start, str)) )
            {
            }
            else
            {
                throw Broker::InvalidScheduleParameter("'start' is not a time",
                                                       sp[lpc]);
            }
        }
        else if( strcasecmp(sp[lpc].name.in(), "pid") == 0 )
        {
            CORBA::Long c_pid;
            const char *str;

            if( pid != -1 )
            {
                throw Broker::DuplicateScheduleParameter("pid");
            }
            else if( sp[lpc].value >>= c_pid )
            {
                pid = c_pid;
            }
            else if( (sp[lpc].value >>= str) &&
                     (sscanf(str, "%d", &pid) == 1) )
            {
            }
            else
            {
                throw Broker::InvalidScheduleParameter("'pid' not a long",
                                                       sp[lpc]);
            }
            if( pid < 0 )
            {
                pid = -1;
                throw Broker::InvalidScheduleParameter("'pid' not a long",
                                                       sp[lpc]);
            }
        }
        else if( strcasecmp(sp[lpc].name.in(), "period") == 0 )
        {
            CORBA::ULong period_ul;
            
            if( period != ~0ULL )
            {
                throw Broker::DuplicateScheduleParameter("period");
            }
            else if( sp[lpc].value >>= period_ul )
            {
                period = period_ul;
            }
            else if( (sp[lpc].value >>= str) &&
                     string_to_microsec(&period, str) )
            {
            }
            else
            {
                throw Broker::InvalidScheduleParameter(
                        "'period' is not a time",
                        sp[lpc]);
            }
        }
        else if( strcasecmp(sp[lpc].name.in(), "deadline") == 0 )
        {
            CORBA::ULong deadline_ul;
            
            if( deadline != ~0ULL )
            {
                throw Broker::DuplicateScheduleParameter("deadline");
            }
            else if( sp[lpc].value >>= deadline_ul )
            {
                deadline = deadline_ul;
            }
            else if( (sp[lpc].value >>= str) &&
                     string_to_microsec(&deadline, str) )
            {
            }
            else
            {
                throw Broker::InvalidScheduleParameter(
                        "'deadline' is not a time",
                        sp[lpc]);
            }
        }
    }
    
    /* Make sure we have everything we need */
    if( period == ~0ULL )
    {
        throw Broker::MissingScheduleParameter("period");
    }
    if( pid == -1 )
    {
        throw Broker::MissingScheduleParameter("pid");
    }
    
    /* ... and derive the rest. */
    if( deadline == ~0ULL )
    {
        deadline = period;
    }

    this->rts_Start = start;
    this->rts_Deadline = deadline;
    this->rts_Period = period;
    this->rts_PID = pid;
}

RealTimeSchedule::~RealTimeSchedule()
{
}

CORBA::ULong RealTimeSchedule::intersect(CORBA::ULong start, CORBA::ULong stop)
{
    int starting_period_index, ending_period_index;
    CORBA::ULong retval = 0;

    require(start <= stop);

    /*
     * The strategy here is to compute the set of periods in this schedule that
     * overlap with the given time frame.  Then we simply add the all the ones
     * in the middle and the starting and ending periods which may be partially
     * covered by the time frame.
     */

    /* Compute the index of the first period. */
    starting_period_index = ((int)start - (int)this->rts_Start) /
        (int)this->rts_Period;
    /* The last intersected period is */
    if( stop < this->rts_Start )
    {
        /* ... before this schedule starts, do nothing. */
        ending_period_index = -1;
    }
    else
    {
        /*
         * in the middle.  (Since there is no stop time in the schedule, there
         * is always a middle)
         */
        ending_period_index = (stop - this->rts_Start - 1) / this->rts_Period;
    }
    /* The start of the intersection is */
    if( starting_period_index < 0 )
    {
        /*
         * ... before this schedules start time.  Therefore, the starting
         * period is completely covered.  We set the value to -1 here so that
         * the computation of periods in the middle will work properly.
         */
        starting_period_index = -1;
    }
    else
    {
        unsigned long long start_us, end_us;

        /*
         * ... possibly in the middle of a period.  Therefore, we need to
         * compute the absolute start of the intersecting period and
         */
        start_us = this->rts_Start +
            (this->rts_Period * starting_period_index);
        /* ... the absolute end of the intersecting period. */
        end_us = this->rts_Start +
            (this->rts_Period * starting_period_index) +
            this->rts_Deadline;
        /* Then add the part of the period that actually intersects. */
        retval += (CORBA::ULong)(min(stop, end_us) - max(start, start_us));
    }
    /* If the intersection covers several periods then */
    if( (starting_period_index + 1) <= (ending_period_index - 1) )
    {
        /* ... add those to the return value. */
        retval += (ending_period_index - starting_period_index - 1) *
            this->rts_Deadline;
    }
    /* Add to the return value if the intersection ends */
    if( ending_period_index < 0 )
    {
        /* ... before this schedule starts. */
    }
    else if( starting_period_index != ending_period_index )
    {
        unsigned long long start_us;

        /* ... at a period not covered by the previous cases (start/middle). */
        start_us = this->rts_Start + (this->rts_Period * ending_period_index);
        retval += (CORBA::ULong)(min(stop, start_us + this->rts_Deadline) -
                                 start_us);
    }
    return( retval );
}

---