StrictPolicyImpl.hh

Go to the documentation of this file.

/*
 * StrictPolicyImpl.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 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"

/**
 * 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);
    /** @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 void ChangeTaskCPU(Broker::RealTimeTask_ptr task,
                               CORBA::ULong ct,
                               CORBA::ULong status,
                               CORBA::ULong 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:

    enum {
        TPB_STARVED,
    };

    /*
     * Flags for the TaskPriority structure.
     *
     * TPF_STARVED - The task is starved for resources.  This flag is used to
     * determine whether or not GiveCPU() will give CPU to a task or just
     * return it to the free CPU pool.
     */
    enum {
        TPF_STARVED = (1L << TPB_STARVED),
    };

    /**
     * List node used to track tasks that this policy is managing.
     */
    struct TaskPriority {
        struct lnNode tp_Link;
        unsigned int tp_Flags;
        struct TaskPriority *tp_SubLink;
        RealTimeSchedule tp_Schedule;
        CORBA::ULong tp_SubTime;
        CORBA::ULong tp_ComputeTime;
        Broker::RealTimeTask_var tp_Task;
    };

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

    /**
     * Construct a list, ordered from lowest to highest priority, of the tasks
     * whose schedule intersects with the given one.
     *
     * @param rts The schedule to match.
     * @param ignore The TaskPriority node to ignore when building the list or
     *               NULL if no nodes should be ignored.
     * @return The list of nodes, linked by tp_SubLink, that match the given
     *         schedule.
     */
    struct TaskPriority *SubList(const RealTimeSchedule &rts,
                                 struct TaskPriority *ignore);

    /**
     * Take CPU time from other tasks to give to another.
     *
     * @param sub_list The list of tasks to take CPU time from, typically built
     *                 with the SubList() method.
     * @param amount The amount of CPU time to take away.
     * @param for_tp The node that will be given the CPU time.
     * @return The actual amount of CPU time that can be given to the task.
     */
    CORBA::ULong TakeCPU(struct TaskPriority *sub_list,
                         CORBA::ULong amount,
                         struct TaskPriority *for_tp);

    /**
     * Give CPU time back to the other tasks.
     *
     * @param sub_list The list of tasks to give CPU time to, typically  built
     *                 with the SubList() method.
     * @param amount The amount of CPU time to give out.
     * @param for_tp The donating task.
     * @return XXX ...
     */
    CORBA::ULong GiveCPU(struct TaskPriority *sub_list,
                         CORBA::ULong amount,
                         struct TaskPriority *for_tp);

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

    /** Fake task object used to represent CPU time that is not reserved. */
    struct TaskPriority sp_FauxTask;

};

#endif

---