MaxDecayTaskAdvocate.cc

Go to the documentation of this file.

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

#include "config.h"

#include <iostream>

#include <instrumentation.h>

#include "MaxDecayTaskAdvocate.hh"

using namespace std;

#ifndef max
#define max(x, y) (((x) > (y)) ? (x) : (y))
#endif

/**
 * The default number of periods to wait before dropping the reservation to the
 * currently observed minimum.
 */
#define DECAY_AFTER 5

MaxDecayTaskAdvocate::MaxDecayTaskAdvocate(void)
{
    this->md_LastAdvice = 0;
    this->md_Decay = DECAY_AFTER;
    this->md_DecayAfter = DECAY_AFTER;
}

MaxDecayTaskAdvocate::~MaxDecayTaskAdvocate(void)
{
}

void MaxDecayTaskAdvocate::SetDelegateAttribute(const char *name,
                                                const CORBA::Any &value)
    throw (CORBA::SystemException)
{
    if( (strcasecmp(name, "decay_after") == 0) ||
        (strcasecmp(name, "decay-after") == 0) ||
        (strcasecmp(name, "decay after") == 0) )
    {
        const char *str;
        
        if( value >>= this->md_DecayAfter )
        {
        }
        else if( (value >>= str) &&
                 (sscanf(str, "%d", &this->md_DecayAfter) == 1) )
        {
        }
        else
        {
            throw CORBA::BAD_PARAM();
        }
    }
    else
    {
        this->RealTimeTaskDelegateImpl::SetDelegateAttribute(name, value);
    }
}

CORBA::Any_ptr MaxDecayTaskAdvocate::GetDelegateAttribute(const char *name)
    throw (CORBA::SystemException)
{
    CORBA::Any_var retval;
    
    if( name == NULL )
    {
        throw CORBA::BAD_PARAM();
    }
    else if( (strcasecmp(name, "decay_after") == 0) ||
             (strcasecmp(name, "decay-after") == 0) ||
             (strcasecmp(name, "decay after") == 0) )
    {
        retval = new CORBA::Any();
        (*retval) <<= this->md_DecayAfter;
    }
    else if( (strcasecmp(name, "last_advice") == 0) ||
             (strcasecmp(name, "last-advice") == 0) ||
             (strcasecmp(name, "last advice") == 0) )
    {
        retval = new CORBA::Any();
        (*retval) <<= this->md_LastAdvice;
    }
    else
    {
        retval = this->RealTimeTaskDelegateImpl::GetDelegateAttribute(name);
    }
    return( retval._retn() );
}

Broker::CPUReserve MaxDecayTaskAdvocate::PassCPU(Broker::RealTimeTask_ptr rtt,
                                                 const Broker::CPUReserve &status,
                                                 const Broker::CPUReserve &advice,
                                                 const Broker::KeyedReportParameters &krp)
    throw (CORBA::SystemException)
{
    Broker::CPUReserve new_advice = advice;
    
    if( CORBA::is_nil(this->dm_RemoteObject.in()) )
    {
        throw CORBA::BAD_INV_ORDER();
    }

    if( new_advice.Compute >= this->md_LastAdvice )
    {
        /* The incoming advice is larger than even our last, start over. */
        this->md_Decay = this->md_DecayAfter;
        this->md_SubMax = 0;
        new_advice.Compute += (CORBA::ULong)(0.01 * new_advice.Compute);
    }
    else if( this->md_Decay >= 0 )
    {
        /* The incoming advice is smaller than our last: update the max and */
        this->md_SubMax = max(this->md_SubMax, new_advice.Compute);
        this->md_Decay -= 1;
        /* ... see if it is time to decay. */
        if( this->md_Decay == 0 )
        {
            new_advice.Compute = (CORBA::ULong)
                (this->md_SubMax + (0.01 * this->md_SubMax));
            this->md_SubMax = 0;
            this->md_Decay = this->md_DecayAfter;
        }
        else
        {
            new_advice.Compute = this->md_LastAdvice;
        }
    }
    this->md_LastAdvice = new_advice.Compute;
    return this->RealTimeTaskDelegateImpl::PassCPU(rtt,
                                                   status,
                                                   new_advice,
                                                   krp);
}

---