StubRealTimeTask.hh

Go to the documentation of this file.

/*
 * StubRealTimeTask.hh
 *
 * 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 StubRealTimeTask.hh
 *
 * Header file and implementation for the StubRealTimeTask class.
 */

#ifndef _stub_real_time_task_hh
#define _stub_real_time_task_hh

#include <time_util.h>

#include "BrokerS.h"

/**
 * A Broker::RealTimeTask class that can be used for testing.
 */
class StubRealTimeTask : public POA_Broker::RealTimeTask
{

public:

    /**
     * Construct an empty StubRealTimeTask object.
     */
    StubRealTimeTask(const char *name)
    {
        this->srtt_Name = name;
    };

    /**
     * Deconstruct a StubTask object.
     */
    virtual ~StubRealTimeTask()
    {
    };

    /**
     * @return The name passed in the constructor.
     */
    virtual char *Name()
        throw (CORBA::SystemException)
    {
        return( this->srtt_Name._retn() );
    };

    /**
     * Basic implementation of Broker::Task::BeginCPUScheduling.
     *
     * @param manager Stored internally.
     * @param sp Specifies the "period" and/or "deadline" values.
     */
    virtual void BeginCPUScheduling(Broker::Manager_ptr manager,
                                    const Broker::ScheduleParameters &sp)
        throw (CORBA::SystemException,
               Broker::DuplicateScheduleParameter,
               Broker::InvalidScheduleParameter,
               Broker::MissingScheduleParameter)
    {
        CORBA::ULongLong period = ~0, deadline = ~0;
        unsigned int lpc;
        const char *str;
        
        this->srtt_Manager = Broker::Manager::_duplicate(manager);
        for( lpc = 0; lpc < sp.length(); lpc++ )
        {
            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");
        }
        /* ... and derive the rest. */
        if( deadline == ~0ULL )
        {
            deadline = period;
        }
        
        this->srtt_Period = period;
        this->srtt_Deadline = deadline;
    };

    /**
     * Empty implementation of Broker::Task::EndCPUScheduling.
     */
    virtual void EndCPUScheduling(void)
        throw (CORBA::SystemException)
    {
        this->srtt_Manager = Broker::Manager::_nil();
    };

    /** @copydoc Broker::RealTimeTask::Period */
    virtual CORBA::ULong Period(void)
        throw (CORBA::SystemException)
    {
        return( this->srtt_Period );
    };

    /** @copydoc Broker::RealTimeTask::Deadline */
    virtual CORBA::ULong Deadline(void)
        throw (CORBA::SystemException)
    {
        return( this->srtt_Deadline );
    };

    /** @copydoc Broker::RealTimeTask::GetComputeTime */
    virtual CORBA::ULong GetComputeTime(void)
        throw (CORBA::SystemException)
    {
        return( this->srtt_ComputeTime );
    };

    /** @copydoc Broker::RealTimeTask::SetComputeTime */
    virtual void SetComputeTime(CORBA::ULong usecs)
        throw (CORBA::SystemException)
    {
        this->srtt_ComputeTime = usecs;
    };

    /** @copydoc Broker::RealTimeTask::ReportCPU */
    virtual void ReportCPU(Broker::RealTimeTask_ptr rtt,
                           CORBA::ULong status,
                           CORBA::ULong advice)
        throw (CORBA::SystemException)
    {
        this->srtt_Manager->ChangeTaskCPU(rtt,
                                          this->srtt_ComputeTime,
                                          status,
                                          advice);
    };

private:

    /**
     * The Broker::Manager used to handle scheduling during contention.  Only
     * valid between #BeginCPUScheduling and #EndCPUScheduling calls.
     */
    Broker::Manager_var srtt_Manager;
    
    /**
     * The task name.
     */
    CORBA::String_var srtt_Name;

    /**
     * The task's period.
     */
    CORBA::ULong srtt_Period;

    /**
     * The task's deadline.
     */
    CORBA::ULong srtt_Deadline;

    /**
     * The task compute time.
     */
    CORBA::ULong srtt_ComputeTime;
    
};

#endif

---