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_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 */
    char *Name(void)
        throw (CORBA::SystemException);
    
    /** @copydoc Broker::Policy::AddTask */
    void AddTask(Broker::Task_ptr task)
        throw (CORBA::SystemException);
    /** @copydoc Broker::Policy::RemoveTask */
    void RemoveTask(Broker::Task_ptr task)
        throw (CORBA::SystemException);
    
    /** @copydoc Broker::Policy::Activate */
    void Activate(const Broker::TaskList &tl)
        throw (CORBA::SystemException);
    /** @copydoc Broker::Policy::Deactivate */
    void Deactivate(void)
        throw (CORBA::SystemException);
    
    /** @copydoc Broker::Policy::ChangeTaskCPU */
    void ChangeTaskCPU(Broker::RealTimeTask_ptr task,
                       CORBA::ULong ct,
                       CORBA::ULong status,
                       CORBA::ULong advice)
        throw (CORBA::SystemException, Broker::InvalidState);

    /** @copydoc StrictPolicy::GetTaskPriority */
    Broker::TaskList *GetTaskList(void)
        throw (CORBA::SystemException);

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

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

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

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

private:

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

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

#endif

---