ManagerImpl.hh

Go to the documentation of this file.

/*
 * ManagerImpl.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 ManagerImpl.hh
 *
 * Header file for the default implementation of the Broker::Manager interface.
 */

#ifndef _manager_impl_hh
#define _manager_impl_hh

#include "BrokerS.h"

#include <listNode.h>

/**
 * A default implementation of the Broker::Manager interface.
 */
class ManagerImpl : public virtual POA_Broker::Manager
{

public:

    /**
     * Construct a ManagerImpl.
     *
     * @param name The name of this manager.
     */
    ManagerImpl(const char *name);

    /**
     * Destruct a ManagerImpl.
     */
    virtual ~ManagerImpl();

    /** @copydoc Broker::Manager::CurrentPolicy */
    virtual Broker::Policy_ptr CurrentPolicy(void)
        throw (CORBA::SystemException);
    
    /** @copydoc Broker::Manager::CurrentPolicy */
    virtual void CurrentPolicy(Broker::Policy_ptr policy)
        throw (CORBA::SystemException);

    /** @copydoc Broker::Manager::AddTask */
    virtual void AddTask(Broker::Task_ptr task,
                         const Broker::ScheduleParameters &sp)
        throw (CORBA::SystemException,
               Broker::DuplicateScheduleParameter,
               Broker::InvalidScheduleParameter,
               Broker::MissingScheduleParameter);

    /** @copydoc Broker::Manager::RemoveTask */
    virtual void RemoveTask(Broker::Task_ptr task)
        throw (CORBA::SystemException);

    /** @copydoc Broker::Manager::GetTaskList */
    virtual Broker::TaskList *GetTaskList(void)
        throw (CORBA::SystemException);

    /** @copydoc Broker::Manager::ChangeTaskCPU */
    virtual Broker::CPUReserve ChangeTaskCPU(Broker::RealTimeTask_ptr task,
                                             const Broker::CPUReserve &advice)
        throw (CORBA::SystemException, Broker::InvalidState);

    /**
     * Search of a task name in a Broker::TaskList.  Or, if the name is an IOR
     * return a reference to that object.
     *
     * @param orb A pointer to an active CORBA::ORB object.
     * @param tl The task list to search.
     * @param name The task name or task IOR.
     * @return An object reference that matches the given name or IOR.
     * @exception CORBA::BAD_PARAM if the task could not be found.
     */
    static Broker::Task_ptr ResolveTask(CORBA::ORB_ptr orb,
                                        Broker::TaskList &tl,
                                        const char *name)
        throw (CORBA::SystemException);
    
private:

    /**
     * List node used to track the tasks that are currently being managed.
     */
    struct TaskNode
    {
        ~TaskNode(void)
        {
            if( !CORBA::is_nil(this->tn_Task.in()) )
            {
                try
                {
                    this->tn_Task->EndCPUScheduling();
                }
                catch(const CORBA::Exception &e)
                {
                }
                try
                {
                    this->tn_Task->SetManager(Broker::Manager::_nil());
                }
                catch(const CORBA::Exception &e)
                {
                }
                this->tn_Task = Broker::Task::_nil();
            }
        };
        
        struct lnMinNode tn_Link;
        Broker::Task_var tn_Task;
        Broker::ScheduleParameters_var tn_ScheduleParameters;
        
    };

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

    /**
     * Find a TaskNode in the task list.
     *
     * @param task The task to search for.
     * @return The corresponding TaskNode for the given task or NULL if none
     * was found.
     */
    struct TaskNode *FindTask(Broker::Task_ptr task);
    
    /**
     * The active policy object or nil.
     */
    Broker::Policy_var mi_CurrentPolicy;

    /**
     * The list of tasks currently being managed.  This list will be passed
     * to policies when they are Broker::Policy::Activate()'d.
     */
    struct lnMinList mi_Tasks;

};

#endif

---