RKTask.hh

Go to the documentation of this file.

/*
 * RKTask.hh
 *
 * 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 RKTask.hh
 *
 * Header file for the TimeSys implementation of Broker::RealTimeTask.
 */

#ifndef _rktask_impl_hh
#define _rktask_impl_hh

#include <rk.h>

#include "BrokerS.h"

/**
 * An implementation of Broker::RealTimeTask for the TimeSys resource kernel.
 * The class will create an rk_resource_set for every process on construction
 * and maintain it until destruction.
 */
class RKTask : public virtual POA_Broker::RealTimeTask
{
    
public:

    /**
     * Construct an RKTask from the given parameters.  The current set of
     * recognized parameters are:
     *
     * @li @e name A string to be used as the name of the task.  (@e required)
     * @li @e pid A long that contains the process ID to manage.  (@e required)
     *
     * @param tp The list of parameters.
     *
     * @exception CORBA::SystemException for CORBA related errors.
     * @exception Broker::InvalidTaskParameter if one of the parameters is
     *            invalid.
     * @exception Broker::MissingTaskParameter if one of the required
     *            parameters is missing.
     */
    RKTask(const Broker::TaskParameters &tp)
        throw (CORBA::SystemException,
               Broker::DuplicateTaskParameter,
               Broker::InvalidTaskParameter,
               Broker::MissingTaskParameter);

    /**
     * Destruct an RKTask.
     */
    virtual ~RKTask();

    /** @copydoc Broker::Task::Name */
    virtual char *Name(void)
        throw (CORBA::SystemException);

    /** @copydoc Broker::RealTimeTask::Period */
    virtual CORBA::ULong Period(void)
        throw (CORBA::SystemException);

    /** @copydoc Broker::RealTimeTask::Deadline */
    virtual CORBA::ULong Deadline(void)
        throw (CORBA::SystemException);

    /** @copydoc Broker::Task::SetManager */
    virtual void SetManager(Broker::Manager_ptr man)
        throw (CORBA::SystemException);

    /** @copydoc Broker::Task::BeginCPUScheduling */
    virtual void BeginCPUScheduling(const Broker::ScheduleParameters &cs)
        throw (CORBA::SystemException,
               Broker::DuplicateScheduleParameter,
               Broker::InvalidScheduleParameter,
               Broker::MissingScheduleParameter);
    
    /** @copydoc Broker::Task::EndCPUScheduling */
    virtual void EndCPUScheduling(void)
        throw (CORBA::SystemException);

    /** @copydoc Broker::RealTimeTask::GetComputeTime */
    virtual CORBA::ULong GetComputeTime(void)
        throw (CORBA::SystemException);
    
    /** @copydoc Broker::RealTimeTask::SetComputeTime */
    virtual void SetComputeTime(CORBA::ULong usecs)
        throw (CORBA::SystemException);

    /** @copydoc Broker::RealTimeTask::ReportCPU */
    virtual void ReportCPU(Broker::RealTimeTask_ptr rtt,
                           CORBA::ULong status,
                           CORBA::ULong advice)
        throw (CORBA::SystemException);

    /** @copydoc Broker::RealTimeTask::ReportCPU */
    virtual void ReportCPU2(CORBA::ULong status,
                            CORBA::ULong advice)
        throw (CORBA::SystemException)
    {
        this->ReportCPU(this->_this(), status, advice);
    };

protected:

    /**
     * The name of the task and the resource set created for it.
     *
     * @invariant != NULL
     */
    CORBA::String_var rkt_Name;

    /**
     * The resource set for the process.
     */
    rk_resource_set_t rkt_ResourceSet;

    /**
     * Flag used to indicate whether or not we allocated the resource set.
     */
    char rkt_OwnsResourceSet;

    /**
     * Caches the value of the CPU reservation when scheduling is active and
     * maintains the values when not active.
     *
     * @invariant .compute_time <= .period
     * @invariant .deadline <= .period
     */
    struct cpu_reserve_attr rkt_CPUReserveSpec;
    
    /**
     * The Broker::Manager used to handle scheduling during contention.  Only
     * valid between #BeginCPUScheduling and #EndCPUScheduling calls.
     */
    Broker::Manager_var rkt_Manager;

    /**
     * The CPU reserve for the process.  Only valid between #BeginCPUScheduling
     * and #EndCPUScheduling calls.
     */
    rk_reserve_t rkt_CPUReserve;

    /**
     * The time of day that this object was constructed.
     */
    struct timeval rkt_StartTime;

    /**
     * The last time a reservation change was logged.
     */
    struct timeval rkt_LastReservationLog;

    /**
     * The output stream for the reservation log file.
     */
    ofstream *rkt_ReservationLog;
    
};

#endif

---