WeightedPolicyImpl.hh

Go to the documentation of this file.

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

#ifndef _weighted_policy_impl_hh
#define _weighted_policy_impl_hh

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

#include "StrictPolicyS.h"

#include "RealTimeSchedule.hh"

#include "listNode.h"

/**
 * An implementation of the WeightedPolicy interface.
 */
class WeightedPolicyImpl : public virtual POA_BrokerPolicies::WeightedPolicy
{
    
public:

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

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

    /** @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 Broker::Policy::GetMaxCPUAllocation */
    virtual CORBA::Float GetMaxCPUAllocation(void)
        throw (CORBA::SystemException);
    /** @copydoc Broker::Policy::SetMaxCPUAllocation */
    virtual void SetMaxCPUAllocation(CORBA::Float amount)
        throw (CORBA::SystemException);

    /** @copydoc BrokerPolicies::WeightedPolicy::SetTaskWeight */
    virtual void SetTaskWeight(Broker::Task_ptr task, CORBA::UShort weight)
        throw (CORBA::SystemException);

    /** @copydoc BrokerPolicies::WeightedPolicy::GetTaskWeight */
    virtual CORBA::UShort GetTaskWeight(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 TaskData;

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

    /**
     * List node used to track tasks that this policy is managing.
     */
    struct TaskData {
        struct lnMinNode td_Link;
        RealTimeSchedule td_Schedule;
        CORBA::UShort td_Weight;
        CORBA::ULong td_ComputeTime;
        CORBA::ULong td_RequestedTime;
        rts_schedulable_t td_Schedulable;
        Broker::RealTimeTask_var td_Task;
        struct ChangeNode td_ChangeLink;
    };

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

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

    /**
     * Redistribute CPU to any tasks managed by this policy.
     */
    void RedistributeCPU(void);
    
    /** The name of this object as registered with the NamingService. */
    CORBA::String_var wp_Name;

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

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

    /** A list of TaskData objects */
    struct lnList wp_List;
    
    /** The largest deadline of the tasks managed by this policy. */
    CORBA::ULong wp_MaxDeadline;

    /** Cached value for the weighted compute time of all the tasks. */
    unsigned long long wp_TotalWeightedComputeTime;
    
};

#endif

---