StrictPolicyImpl.hh

Go to the documentation of this file.

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

#ifndef _strict_policy_impl_hh
#define _strict_policy_impl_hh

#include "BrokerC.h"
#include "BrokerS.h"

#include "StrictPolicyS.h"

#include "RealTimeSchedule.hh"

#include "listNode.h"
#include "rt_scheduler.h"

/**
 * An implementation of the StrictPolicy interface.
 */
class StrictPolicyImpl : public virtual POA_BrokerPolicies::StrictPolicy
{
    
public:

    /**
     * Construct a StrictPolicyImpl object with the given values.
     *
     * @param name The name of this object as registered with the
     *             NamingService.
     */
    StrictPolicyImpl(const char *name);

    /**
     * Deconstruct the policy.
     */
    virtual ~StrictPolicyImpl();

    /** @copydoc Broker::Policy::Name */
    virtual char *Name(void)
        throw (CORBA::SystemException);
    
    /** @copydoc Broker::Policy::AddTask */
    virtual void AddTask(Broker::Task_ptr new_task,
                         const Broker::ScheduleParameters &sp)
        throw (CORBA::SystemException,
               Broker::DuplicateScheduleParameter,
               Broker::InvalidScheduleParameter,
               Broker::MissingScheduleParameter);
    /** @copydoc Broker::Policy::RemoveTask */
    virtual void RemoveTask(Broker::Task_ptr added_task)
        throw (CORBA::SystemException);
    
    /** @copydoc Broker::Policy::GetTaskList */
    virtual Broker::TaskList *GetTaskList(void)
        throw (CORBA::SystemException);

    /** @copydoc Broker::Policy::Activate */
    virtual void Activate(const Broker::TaskList &tasks)
        throw (CORBA::SystemException);
    /** @copydoc Broker::Policy::Deactivate */
    virtual void Deactivate(void)
        throw (CORBA::SystemException);
    
    /** @copydoc Broker::Policy::ChangeTaskCPU */
    virtual Broker::CPUReserve ChangeTaskCPU(Broker::RealTimeTask_ptr task,
                                             const Broker::CPUReserve &advice)
        throw (CORBA::SystemException, Broker::InvalidState);

    /** @copydoc BrokerPolicies::StrictPolicy::GetMaxCPUAllocation */
    virtual CORBA::Float GetMaxCPUAllocation(void)
        throw (CORBA::SystemException);
    /** @copydoc BrokerPolicies::StrictPolicy::SetMaxCPUAllocation */
    virtual void SetMaxCPUAllocation(CORBA::Float amount)
        throw (CORBA::SystemException);

    /** @copydoc BrokerPolicies::StrictPolicy::SetTaskPriority */
    virtual void SetTaskPriority(Broker::Task_ptr task, CORBA::Short priority)
        throw (CORBA::SystemException);

    /** @copydoc BrokerPolicies::StrictPolicy::GetTaskPriority */
    virtual CORBA::Short GetTaskPriority(Broker::Task_ptr task)
        throw (CORBA::SystemException);

    /**
     * Maximum percentage of CPU to allocate to tasks.
     */
    const static float DEFAULT_MAX_USED_CPU = 0.75;

    /**
     * Minimum percentage of CPU to allocate to a single task.
     */
    const static float DEFAULT_MIN_TASK_CPU = 0.02;

private:

    struct TaskPriority;

    /**
     * List node used to track changes to be made in the low-level scheduler.
     */
    struct ChangeNode {
        struct lnMinNode cn_Link;
        struct TaskPriority *cn_Parent;
        CORBA::ULong cn_NewTime;
    };

    /**
     * List node used to track tasks that this policy is managing.
     */
    struct TaskPriority {
        struct lnNode tp_Link;
        RealTimeSchedule tp_Schedule;
        CORBA::ULong tp_ComputeTime;
        CORBA::ULong tp_RequestedTime;
        rts_schedulable_t tp_Schedulable;
        Broker::RealTimeTask_var tp_Task;
        struct ChangeNode tp_ChangeLink;
    };

    /**
     * Repair the task list by removing any dead/unreachable objects.
     */
    void RepairTaskList(void);

    /**
     * Find the TaskPriority node that corresponds to the given task.
     *
     * @param task The Broker::RealTimeTask object to look up.
     * @return The TaskPriority list node that has the given task object.
     * @exception Broker::Internal If no TaskPriority node exists for the given
     *            task.
     */
    struct TaskPriority *FindTaskPriority(Broker::RealTimeTask_ptr task);

    /**
     * Detect changes in the amount of requested/available compute time or
     * priorities, and map them onto the OS scheduler.
     */
    void RedistributeCPU(void);
    
    /** The name of this object as registered with the NamingService. */
    CORBA::String_var sp_Name;

    /** The maximum percentage of CPU time that we are allowed to allocate. */
    float sp_MaxUsedCPU;

    /** The minimum percentage of CPU time that a task must have. */
    float sp_MinTaskCPU;

    /** A list of TaskPriority objects */
    struct lnList sp_List;
    
    /** The largest deadline of the tasks managed by this policy. */
    CORBA::ULong sp_MaxDeadline;

};

#endif

---