RealTimeSchedule.cc

Go to the documentation of this file.

/*
 * RealTimeSchedule.cc
 *
 * 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 RealTimeSchedule.cc
 *
 * Implementation of the RealTimeSchedule class.
 */

#include "config.h"

#include <assert_pp.h>

#include <iostream>

#include "RealTimeSchedule.hh"

#if !defined(min)
#define min(x, y) ((x) < (y) ? (x) : (y))
#define max(x, y) ((x) > (y) ? (x) : (y))
#endif

RealTimeSchedule::RealTimeSchedule(CORBA::ULong start,
                                   CORBA::ULong period,
                                   CORBA::ULong deadline) :
    rts_Start(start), rts_Period(period), rts_Deadline(deadline)
{
    require(deadline <= period);
}

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 );
}

---