StubPolicy.hh

Go to the documentation of this file.

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

#ifndef _stub_policy_hh
#define _stub_policy_hh

#include "BrokerS.h"

/**
 * A Broker::Policy subclass that can be used for testing.
 */
class StubPolicy : public POA_Broker::Policy
{

public:

    /**
     * Construct a StubPolicy object with the given value.
     *
     * @param name The policy name.
     */
    StubPolicy(const char *name)
    {
        this->sp_Name = name;
    };

    /**
     * Deconstruct a StubPolicy object.
     */
    virtual ~StubPolicy()
    {
    };

    /**
     * @return The name passed to the constructor.
     */
    char *Name(void)
        throw (CORBA::SystemException)
    {
        CORBA::String_var retval;

        retval = this->sp_Name;
        return( retval._retn() );
    }

    /**
     * Add a task to the sp_Tasks list.
     *
     * @param task The task to add to the policy.
     * @param sp The task's scheduling parameters.
     */
    void AddTask(Broker::Task_ptr task, const Broker::ScheduleParameters &sp)
        throw (CORBA::SystemException,
               Broker::DuplicateScheduleParameter,
               Broker::InvalidScheduleParameter,
               Broker::MissingScheduleParameter)
    {
        unsigned int slot;

        slot = this->sp_Tasks.length();
        this->sp_Tasks.length(slot + 1);
        this->sp_Tasks[slot] = Broker::Task::_duplicate(task);
    };

    /**
     * Remove a task from the sp_Tasks list.
     *
     * @param task The task to remove from the policy.
     */
    void RemoveTask(Broker::Task_ptr task)
        throw (CORBA::SystemException)
    {
        unsigned int lpc;
        int slot;

        slot = this->TaskIndex(task);
        for( lpc = (unsigned int)slot;
             lpc < (this->sp_Tasks.length() - 1);
             lpc++ )
        {
            this->sp_Tasks[lpc] = this->sp_Tasks[lpc + 1];
        }
        this->sp_Tasks.length(this->sp_Tasks.length() - 1);
    };

    /**
     * @return The list of tasks that have been added to this policy.
     */
    Broker::TaskList *GetTaskList(void)
        throw (CORBA::SystemException)
    {
        Broker::TaskList_var retval;

        retval = new Broker::TaskList(this->sp_Tasks);
        return( retval._retn() );
    };

    /**
     * Activate the policy and add the given list of tasks to sp_Tasks.
     *
     * @param tasks The existing tasks being handled by the broker.
     */
    void Activate(const Broker::TaskList &tasks)
        throw (CORBA::SystemException)
    {
        unsigned int lpc;

        this->sp_Tasks.length(tasks.length());
        for( lpc = 0; lpc < tasks.length(); lpc++ )
        {
            this->sp_Tasks[lpc] = tasks[lpc];
        }
    };

    /**
     * Deactivate the policy and set the length of sp_Tasks to zero.
     */
    void Deactivate(void)
        throw (CORBA::SystemException)
    {
        this->sp_Tasks.length(0);
    };

    /**
     * Change the compute time for the given task to the given advice.
     *
     * @param task The task whose compute time should be changed.
     * @param advice The advocate's advice.
     */
    Broker::CPUReserve ChangeTaskCPU(Broker::RealTimeTask_ptr task,
                                     const Broker::CPUReserve &advice)
        throw (CORBA::SystemException, Broker::InvalidState)
    {
        Broker::CPUReserve retval;

        retval = advice;
        retval.Compute = 0;
        return retval;
    };

    /** @copydoc Broker::Policy::GetMaxCPUAllocation */
    virtual CORBA::Float GetMaxCPUAllocation(void)
        throw (CORBA::SystemException)
    {
        return this->sp_MaxCPUAllocation;
    };
    
    /** @copydoc Broker::Policy::SetMaxCPUAllocation */
    virtual void SetMaxCPUAllocation(CORBA::Float amount)
        throw (CORBA::SystemException)
    {
        this->sp_MaxCPUAllocation = amount;
    };

    /**
     * Find a task in the sp_Tasks list.
     *
     * @param task The task to find.
     * @return The index of the task in sp_Tasks or -1 if it could not be
     *         found.
     */
    int TaskIndex(Broker::Task_ptr task)
    {
        unsigned int lpc;
        int retval = -1;
        
        for( lpc = 0;
             (lpc < this->sp_Tasks.length()) && (retval == -1);
             lpc++ )
        {
            if( this->sp_Tasks[lpc]->_is_equivalent(task) )
            {
                retval = lpc;
            }
        }
        return( retval );
    }

    /** The policy's name. */
    CORBA::String_var sp_Name;
    /** The list of tasks being managed by this policy. */
    Broker::TaskList sp_Tasks;
    /** The maximum CPU allocation. */
    CORBA::Float sp_MaxCPUAllocation;
    
};

#endif

---