MinMaxTaskAdvocate.cc

Go to the documentation of this file.

/*
 * MinMaxTaskAdvocate.cc
 *
 * Copyright (c) 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 MinMaxTaskAdvocate.cc
 *
 * Implementation of the MinMaxTaskAdvocate class.
 */

#include "config.h"

#include <limits.h>
#include <iostream>

#include <instrumentation.h>

#include "MinMaxTaskAdvocate.hh"

using namespace std;

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

#ifndef min
#define min(x, y) (((x) < (y)) ? (x) : (y))
#endif

MinMaxTaskAdvocate::MinMaxTaskAdvocate(void)
{
    this->mm_Minimum = 0;
    this->mm_Maximum = ULONG_MAX;
}

MinMaxTaskAdvocate::~MinMaxTaskAdvocate(void)
{
}

void MinMaxTaskAdvocate::SetDelegateAttribute(const char *name,
                                              const CORBA::Any &value)
    throw (CORBA::SystemException)
{
    if( strcasecmp(name, "minimum") == 0 )
    {
        const char *str;
        
        if( value >>= this->mm_Minimum )
        {
        }
        else if( (value >>= str) &&
                 (sscanf(str, "%d", &this->mm_Minimum) == 1) )
        {
        }
        else
        {
            throw CORBA::BAD_PARAM();
        }
    }
    else if( strcasecmp(name, "maximum") == 0 )
    {
        const char *str;
        
        if( value >>= this->mm_Maximum )
        {
        }
        else if( (value >>= str) &&
                 (sscanf(str, "%d", &this->mm_Maximum) == 1) )
        {
        }
        else
        {
            throw CORBA::BAD_PARAM();
        }
    }
    else
    {
        this->RealTimeTaskDelegateImpl::SetDelegateAttribute(name, value);
    }
}

CORBA::Any_ptr MinMaxTaskAdvocate::GetDelegateAttribute(const char *name)
    throw (CORBA::SystemException)
{
    CORBA::Any_var retval;
    
    if( name == NULL )
    {
        throw CORBA::BAD_PARAM();
    }
    else if( strcasecmp(name, "minimum") == 0 )
    {
        retval = new CORBA::Any();
        (*retval) <<= this->mm_Minimum;
    }
    else if( strcasecmp(name, "maximum") == 0 )
    {
        retval = new CORBA::Any();
        (*retval) <<= this->mm_Maximum;
    }
    else
    {
        retval = this->RealTimeTaskDelegateImpl::GetDelegateAttribute(name);
    }
    return( retval._retn() );
}

Broker::CPUReserve
MinMaxTaskAdvocate::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();
    }

    new_advice.Compute = max(new_advice.Compute, this->mm_Minimum);
    new_advice.Compute = min(new_advice.Compute, this->mm_Maximum);
    return this->RealTimeTaskDelegateImpl::PassCPU(rtt,
                                                   status,
                                                   new_advice,
                                                   krp);
}

---