RKTask.hh

Go to the documentation of this file.

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

#ifndef _task_impl_hh
#define _task_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 */
    char *Name(void)
        throw (CORBA::SystemException);

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

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

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

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

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.
     *
     * @invariant != NULL
     */
    rk_resource_set_t rkt_ResourceSet;

    /**
     * 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;

    struct timeval rkt_StartTime;

    struct timeval rkt_LastReservationLog;
    
    ofstream *rkt_ReservationLog;
    
};

#endif

---