StrictPolicyImpl.cc

Go to the documentation of this file.

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

#include "config.h"

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

#include "StubRealTimeTask.hh"
#include "StrictPolicyImpl.hh"

using namespace std;

#undef DEBUG

StrictPolicyImpl::StrictPolicyImpl(const char *name) :
    sp_Name(name)
{
    require(name != NULL);
    
    this->sp_MaxUsedCPU = DEFAULT_MAX_USED_CPU;
    this->sp_MinTaskCPU = DEFAULT_MIN_TASK_CPU;
    lnNewList((struct lnMinList *)&this->sp_List);
}

StrictPolicyImpl::~StrictPolicyImpl()
{
}

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

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

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

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

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

    this->sp_MaxUsedCPU = value;
    this->RedistributeCPU();
}

void StrictPolicyImpl::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 task list is sane, and */
    this->RepairTaskList();
    
    /* ... try to add the new task. */
    /** @todo Handle other types of tasks. */
    rtt = Broker::RealTimeTask::_narrow(task);
    if( !CORBA::is_nil(rtt) )
    {
        struct TaskPriority *tp = NULL;
        CORBA::String_var name;
        int rc;
        
        name = rtt->Name();

        try
        {
            tp = new TaskPriority();
            
            /* Initialize the node and */
            tp->tp_Link.ln_Pred = NULL;
            tp->tp_Link.ln_Succ = NULL;
            tp->tp_Link.ln_Pri = 0;
            tp->tp_Task = Broker::RealTimeTask::_duplicate(rtt);
            
            /* ... cache some values. */
            tp->tp_Schedule.setParameters(sp);
            tp->tp_ComputeTime = tp->tp_RequestedTime = 0;
        }
        catch(const Broker::DuplicateScheduleParameter &e)
        {
            delete tp;
            throw e;
        }
        catch(const Broker::InvalidScheduleParameter &e)
        {
            delete tp;
            throw e;
        }
        catch(const Broker::MissingScheduleParameter &e)
        {
            delete tp;
            throw e;
        }
        
        if( (rc = rts_grab_schedulable(&tp->tp_Schedulable,
                                       tp->tp_Schedule.rts_PID,
                                       name.in())) == -1 )
        {
            cerr << "rts_grab_schedulable: " << strerror(rc) << endl;
        }
        else
        {
            /* Finally, add it to list, ordered by tp_Link.ln_Pri. */
            lnEnqueue(&this->sp_List, &tp->tp_Link);
            tp = NULL;
        }
        
        if( tp != NULL )
        {
            delete tp;
            throw Broker::InvalidScheduleParameter();
        }
    }
}

void StrictPolicyImpl::RemoveTask(Broker::Task_ptr task)
    throw (CORBA::SystemException)
{
    Broker::RealTimeTask_ptr rtt;
    struct TaskPriority *tp;
    int rc;

    this->RepairTaskList();
    
    /* Find the task, */
    try
    {
        rtt = Broker::RealTimeTask::_narrow(task);
        if( (tp = this->FindTaskPriority(rtt)) == NULL )
        {
            throw CORBA::BAD_PARAM();
        }
    }
    catch(const CORBA::TRANSIENT &e)
    {
        throw CORBA::BAD_PARAM();
    }

    lnRemove((struct lnMinNode *)&tp->tp_Link);
    if( (rc = rts_clear_schedule(tp->tp_Schedulable)) == -1 )
    {
        cerr << "rts_clear_schedule: " << strerror(rc) << endl;
    }
    if( (rc = rts_release_schedulable(tp->tp_Schedulable)) == -1 )
    {
        cerr << "rts_release_schedulable: " << strerror(rc) << endl;
    }
    delete tp;

    this->RedistributeCPU();
}

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

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

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

void StrictPolicyImpl::SetTaskPriority(Broker::Task_ptr task,
                                       CORBA::Short priority)
    throw (CORBA::SystemException)
{
    Broker::RealTimeTask_var rtt;
    struct TaskPriority *tp;

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

    /* Remove from the list */
    lnRemove((struct lnMinNode *)&tp->tp_Link);
    /* ... set the new priority */
    tp->tp_Link.ln_Pri = (char)priority;
    /* ... and reinsert to get the new ordering. */
    lnEnqueue(&this->sp_List, &tp->tp_Link);

    this->RedistributeCPU();
}

CORBA::Short StrictPolicyImpl::GetTaskPriority(Broker::Task_ptr task)
    throw (CORBA::SystemException)
{
    Broker::RealTimeTask_var rtt;
    struct TaskPriority *tp;
    CORBA::Short retval;

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

    retval = tp->tp_Link.ln_Pri;
    
    return( retval );
}

void StrictPolicyImpl::RedistributeCPU(void)
{
    struct lnMinList change_list;
    CORBA::Float remaining_cpu;
    struct TaskPriority *curr;
    struct ChangeNode *cn;

    lnNewList(&change_list);
    remaining_cpu = this->sp_MaxUsedCPU;
    curr = (struct TaskPriority *)this->sp_List.lh_Head;
    while( curr->tp_Link.ln_Succ != NULL )
    {
        unsigned long long actual_cpu_time;
        CORBA::Float need_cpu;

        need_cpu = ((float)curr->tp_RequestedTime /
                    (float)curr->tp_Schedule.rts_Deadline);

        if( need_cpu < remaining_cpu )
        {
            actual_cpu_time = curr->tp_RequestedTime;
            remaining_cpu -= need_cpu;
        }
        else
        {
            actual_cpu_time = (unsigned long long)
                ((float)curr->tp_Schedule.rts_Deadline * remaining_cpu);
            remaining_cpu = 0.0;
        }

        cn = &curr->tp_ChangeLink;
        cn->cn_Parent = curr;
        cn->cn_NewTime = actual_cpu_time;
        if( actual_cpu_time == curr->tp_ComputeTime )
        {
            /* no change... */
        }
        else if( actual_cpu_time > curr->tp_ComputeTime )
        {
            lnAddTail(&change_list, &cn->cn_Link);
        }
        else if( actual_cpu_time < curr->tp_ComputeTime )
        {
            lnAddHead(&change_list, &cn->cn_Link);
        }
        else
        {
            assert(0);
        }
        curr = (struct TaskPriority *)curr->tp_Link.ln_Succ;
    }
    curr = NULL;
    
    cn = (struct ChangeNode *)change_list.lh_Head;
    while( cn->cn_Link.ln_Succ != NULL )
    {
        struct TaskPriority *tp;
        
        tp = cn->cn_Parent;
        if( cn->cn_NewTime > 0 )
        {
            struct rts_schedule rs;
            int rc;
            
            rs.rs_Period = microsec_to_timespec(tp->tp_Schedule.rts_Period);
            rs.rs_ComputeTime = microsec_to_timespec(cn->cn_NewTime);
            rs.rs_ReserveMode = tp->tp_Schedule.rts_ReserveMode;
            if( (rc = rts_set_schedule(tp->tp_Schedulable, &rs)) == -1 )
            {
                cerr << "rts_set_schedule: " << strerror(rc) << endl;
            }
            else
            {
                cn->cn_Parent->tp_ComputeTime = cn->cn_NewTime;
            }
        }
        else
        {
            int rc;
            
            if( (rc = rts_clear_schedule(tp->tp_Schedulable)) == -1 )
            {
                cerr << "rts_set_schedule: " << strerror(rc) << endl;
            }
        }
        cn = (struct ChangeNode *)cn->cn_Link.ln_Succ;
    }
}

void StrictPolicyImpl::RepairTaskList(void)
{
    struct TaskPriority *curr, *succ;
    int do_redist = 0;
    
    curr = (struct TaskPriority *)this->sp_List.lh_Head;
    while( curr->tp_Link.ln_Succ != NULL )
    {
        succ = (struct TaskPriority *)curr->tp_Link.ln_Succ;
        try
        {
            CORBA::String_var name = curr->tp_Task->Name();
        }
        catch(const CORBA::TRANSIENT &e)
        {
            lnRemove((struct lnMinNode *)&curr->tp_Link);
            delete curr;
            do_redist = 1;
        }
        curr = succ;
    }
    if( do_redist )
    {
        this->RedistributeCPU();
    }
}

struct StrictPolicyImpl::TaskPriority *
StrictPolicyImpl::FindTaskPriority(Broker::RealTimeTask_ptr task)
{
    struct TaskPriority *curr, *retval = NULL;

    require(task != NULL);
    
    curr = (struct TaskPriority *)this->sp_List.lh_Head;
    while( (retval == NULL) && (curr->tp_Link.ln_Succ != NULL) )
    {
        if( task->_is_equivalent(curr->tp_Task.in()) )
        {
            retval = curr;
        }
        curr = (struct TaskPriority *)curr->tp_Link.ln_Succ;
    }
    return( retval );
}

Broker::CPUReserve
StrictPolicyImpl::ChangeTaskCPU(Broker::RealTimeTask_ptr task,
                                const Broker::CPUReserve &advice)
    throw (CORBA::SystemException, Broker::InvalidState)
{
    Broker::CPUReserve retval = advice;
    struct TaskPriority *tp;

    require(task != NULL);

    if( (tp = this->FindTaskPriority(task)) != NULL )
    {
        tp->tp_Schedule.rts_Period = advice.Period;
        tp->tp_RequestedTime = advice.Compute;
        this->RedistributeCPU();
        retval.Compute = tp->tp_ComputeTime;
    }
    else
    {
        throw Broker::InvalidState("AddTask must be called first");
    }
    return retval;
}

---