PartitionPolicyImpl.cc

Go to the documentation of this file.

/*
 * PartitionPolicyImpl.cc
 *
 * 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 PartitionPolicyImpl.cc
 *
 * Implementation of the PartitionPolicyImpl class.
 */

#include "config.h"

#include <iostream>
#include <assert_pp.h>

#include "StubRealTimeTask.hh"
#include "PartitionPolicyImpl.hh"

using namespace std;

PartitionPolicyImpl::PartitionPolicyImpl(const char *name) :
    pp_Name(name)
{
    require(name != NULL);
    
    lnNewList((struct lnMinList *)&this->pp_List);
}

PartitionPolicyImpl::~PartitionPolicyImpl()
{
}

char *PartitionPolicyImpl::Name(void)
    throw (CORBA::SystemException)
{
    CORBA::String_var retval;

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

CORBA::Float PartitionPolicyImpl::GetMaxCPUAllocation(void)
    throw (CORBA::SystemException)
{
    CORBA::Float retval;

    retval = this->pp_MaxUsedCPU;
    return( retval );
}

void PartitionPolicyImpl::SetMaxCPUAllocation(CORBA::Float value)
    throw (CORBA::SystemException)
{
    if( (value < BrokerPolicies::PartitionPolicy::CPU_ALLOCATION_MIN) ||
        (value > BrokerPolicies::PartitionPolicy::CPU_ALLOCATION_MAX) )
    {
        throw CORBA::BAD_PARAM();
    }

    this->pp_MaxUsedCPU = value;
}

void PartitionPolicyImpl::AddTask(Broker::Task_ptr task,
                                  const Broker::ScheduleParameters &sp)
    throw (CORBA::SystemException,
           Broker::DuplicateScheduleParameter,
           Broker::InvalidScheduleParameter,
           Broker::MissingScheduleParameter)
{
    Broker::RealTimeTask_ptr rtt;
    
    /* Check inputs, */
    if( CORBA::is_nil(task) )
    {
        throw CORBA::BAD_PARAM();
    }

    /* ... make sure our internal list is sane, and */
    this->RepairTaskList();
    
    /* ... try to add the task. */
    rtt = Broker::RealTimeTask::_narrow(task);
    if( !CORBA::is_nil(rtt) )
    {
        /* Make sure there is a default policy and then */
        if( !CORBA::is_nil(this->pp_DefaultPolicy.in()) )
        {
            try
            {
                this->pp_DefaultPolicy->AddTask(task, sp);
            }
            catch(const Broker::DuplicateScheduleParameter &e)
            {
                throw e;
            }
            catch(const Broker::InvalidScheduleParameter &e)
            {
                throw e;
            }
            catch(const Broker::MissingScheduleParameter &e)
            {
                throw e;
            }
        }

        /* ... add it to our own list. */
        struct TaskData *td;
        
        td = new TaskData();
        td->td_Task = Broker::RealTimeTask::_duplicate(rtt);
        td->td_ScheduleParameters = new Broker::ScheduleParameters(sp);
        td->td_Policy = Broker::Policy::
            _duplicate(this->pp_DefaultPolicy.in());
        lnAddTail(&this->pp_List, &td->td_Link);
    }
}

void PartitionPolicyImpl::RemoveTask(Broker::Task_ptr task)
    throw (CORBA::SystemException)
{
    Broker::RealTimeTask_var rtt;
    struct TaskData *td;
    
    this->RepairTaskList();
    
    /* Find the task, */
    try
    {
        rtt = Broker::RealTimeTask::_narrow(task);
        if( (td = this->FindTaskData(rtt.in())) == NULL )
        {
            throw CORBA::BAD_PARAM();
        }
    }
    catch(const CORBA::TRANSIENT &e)
    {
        throw CORBA::BAD_PARAM();
    }
    
    /* ... remove the node, and */
    lnRemove((struct lnMinNode *)&td->td_Link);
    if( !CORBA::is_nil(td->td_Policy.in()) )
    {
        td->td_Policy->RemoveTask(task);
    }
    /* ... delete it. */
    delete td;
}

void PartitionPolicyImpl::Activate(const Broker::TaskList &tl)
    throw (CORBA::SystemException)
{
    /** @todo implement */
}

void PartitionPolicyImpl::Deactivate(void)
    throw (CORBA::SystemException)
{
    /** @todo implement */
}

void PartitionPolicyImpl::DefaultPolicy(Broker::Policy_ptr bp)
    throw (CORBA::SystemException)
{
    this->pp_DefaultPolicy = Broker::Policy::_duplicate(bp);
}

Broker::Policy_ptr PartitionPolicyImpl::DefaultPolicy(void)
    throw (CORBA::SystemException)
{
    Broker::Policy_var retval;

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

Broker::TaskList *PartitionPolicyImpl::GetTaskList(void)
    throw (CORBA::SystemException)
{
    Broker::TaskList_var retval;
    struct TaskData *tp;
    unsigned int lpc = 0;
    
    retval = new Broker::TaskList();
    retval->length(lnCountNodes((struct lnMinList *)&this->pp_List));
    tp = (struct TaskData *)this->pp_List.lh_Head;
    while( tp->td_Link.ln_Succ != NULL )
    {
        (*retval)[lpc] = Broker::Task::_duplicate(tp->td_Task.in());
        lpc += 1;
        tp = (struct TaskData *)tp->td_Link.ln_Succ;
    }
    return( retval._retn() );
}

void PartitionPolicyImpl::SetTaskPolicy(Broker::Task_ptr task,
                                        Broker::Policy_ptr policy)
    throw (CORBA::SystemException)
{
    Broker::RealTimeTask_var rtt;
    struct TaskData *td;

    rtt = Broker::RealTimeTask::_narrow(task);
    if( CORBA::is_nil(rtt.in()) )
    {
        throw CORBA::BAD_PARAM();
    }

    /* Find the task, */
    if( (td = this->FindTaskData(rtt.in())) == NULL )
    {
        throw CORBA::BAD_PARAM();
    }

    /* ... remove it from the old, and */
    if( !CORBA::is_nil(td->td_Policy.in()) )
    {
        td->td_Policy->RemoveTask(task);
    }
    
    /* ... add it to the new. */
    td->td_Policy = Broker::Policy::_duplicate(policy);

    if( !CORBA::is_nil(td->td_Policy.in()) )
    {
        td->td_Policy->AddTask(task, td->td_ScheduleParameters);
    }
}

Broker::Policy_ptr PartitionPolicyImpl::GetTaskPolicy(Broker::Task_ptr task)
    throw (CORBA::SystemException)
{
    Broker::RealTimeTask_var rtt;
    Broker::Policy_var retval;
    struct TaskData *td;

    rtt = Broker::RealTimeTask::_narrow(task);
    if( CORBA::is_nil(rtt.in()) )
    {
        throw CORBA::BAD_PARAM();
    }
    if( (td = this->FindTaskData(rtt.in())) == NULL )
    {
        throw CORBA::BAD_PARAM();
    }

    retval = td->td_Policy;
    
    return( retval._retn() );
}

void PartitionPolicyImpl::RepairTaskList(void)
{
    struct TaskData *curr, *succ;
    
    curr = (struct TaskData *)this->pp_List.lh_Head;
    while( curr->td_Link.ln_Succ != NULL )
    {
        succ = (struct TaskData *)curr->td_Link.ln_Succ;
        try
        {
            CORBA::String_var name = curr->td_Task->Name();
        }
        catch(const CORBA::TRANSIENT &e)
        {
            try
            {
                curr->td_Policy->RemoveTask(curr->td_Task.in());
            }
            catch(const CORBA::BAD_PARAM &e)
            {
                /* Ignore... */
            }
            catch(const CORBA::SystemException &e)
            {
                cerr << "Error while repairing: "
                     << e
                     << " file: "
                     << __FILE__
                     << " line: "
                     << __LINE__
                     << endl;
            }
            lnRemove((struct lnMinNode *)&curr->td_Link);
            delete curr;
        }
        curr = succ;
    }
}

struct PartitionPolicyImpl::TaskData *
PartitionPolicyImpl::FindTaskData(Broker::RealTimeTask_ptr task)
{
    struct TaskData *curr, *retval = NULL;

    require(task != NULL);
    
    curr = (struct TaskData *)this->pp_List.lh_Head;
    while( (retval == NULL) && (curr->td_Link.ln_Succ != NULL) )
    {
        if( task->_is_equivalent(curr->td_Task.in()) )
        {
            retval = curr;
        }
        curr = (struct TaskData *)curr->td_Link.ln_Succ;
    }

    return( retval );
}

Broker::CPUReserve
PartitionPolicyImpl::ChangeTaskCPU(Broker::RealTimeTask_ptr task,
                                   const Broker::CPUReserve &advice)
    throw (CORBA::SystemException, Broker::InvalidState)
{
    Broker::CPUReserve retval = advice;
    struct TaskData *td;

    require(task != NULL);

    /* Try to pass the request on to the real policy. */
    if( (td = this->FindTaskData(task)) != NULL )
    {
        if( !CORBA::is_nil(td->td_Policy.in()) )
        {
            retval = td->td_Policy->ChangeTaskCPU(task, advice);
        }
        else
        {
            retval.Compute = 0;
        }
    }
    else
    {
        throw Broker::InvalidState("AddTask must be called first");
    }
    return retval;
}

---