BasicDelegate.cc

Go to the documentation of this file.

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

#include "config.h"

#include <math.h>

#include <assert_pp.h>

#include <rk_stub.h>

#include "BasicDelegate.hh"

BasicDelegate::BasicDelegate(const char *name,
                             unsigned long period,
                             unsigned long deadline) :
    bd_Period(period), bd_Deadline(deadline)
{
    require(name != NULL);
    require(deadline <= period);

    this->bd_AdviseDrop = 0;
    /* Create the fake process. */
    this->bd_PID = rk_stub_mk_pid(name,
                                  this,
                                  cxx_delegate_precall,
                                  cxx_delegate_postcall);
    
    /* Build up the parameter lists. */
    this->bd_CPUSchedule.length(3);
    this->bd_CPUSchedule[0].name = "period";
    this->bd_CPUSchedule[0].value <<= (CORBA::ULong)period;
    this->bd_CPUSchedule[1].name = "deadline";
    this->bd_CPUSchedule[1].value <<= (CORBA::ULong)deadline;
    this->bd_CPUSchedule[2].name = "pid";
    this->bd_CPUSchedule[2].value <<= this->bd_PID;
    this->bd_TaskDescription.length(1);
    this->bd_TaskDescription[0].name = "name";
    this->bd_TaskDescription[0].value <<= name;
}

BasicDelegate::~BasicDelegate()
{
}

rk_stub_precall_retval_t BasicDelegate::precall(void)
{
    rk_stub_precall_retval_t retval;

    require(this->bd_AdviseDrop >= 0);

    /* Check if we need to do a drop. */
    if( this->bd_AdviseDrop > 0 )
    {
        this->bd_AdviseDrop -= 1;
        retval = RKSP_DROP;
    }
    else
    {
        rk_stub_getrusage(this->bd_PID, &this->bd_RUStart);
        rk_clock_gettime(CLOCK_REALTIME, &this->bd_Start);
        retval = RKSP_OK;
    }

    return( retval );
}

void BasicDelegate::postcall(void)
{
    long long start_us, end_us, diff_us;
    struct rusage ru_end;
    struct timespec end;
    float periods;
    
    require(!CORBA::is_nil(this->bd_Advocate.in()));
    
    rk_stub_getrusage(this->bd_PID, &ru_end);
    rk_clock_gettime(CLOCK_REALTIME, &end);

    /* Figure out how long it took, in microseconds, to process the data. */
    start_us = timespec_to_microsec(&this->bd_Start);
    end_us = timespec_to_microsec(&end);
    diff_us = end_us - start_us;

    cout << "start: " << start_us
         << "; end: " << end_us
         << "; diff: " << diff_us
         << endl;

    /*
     * Now convert the microseconds value to a float value that
     * Broker::RealTimeAdvocate::ReportCPU will understand.
     *
     * First, compute how much time it took between the start of the period
     * and the deadline.
     */
    periods = (float)(diff_us % this->bd_Deadline) / (float)this->bd_Deadline;
    cout << "periods: " << periods << endl;
    if( periods == 0.0 )
    {
        /*
         * Add one if the method finished exactly on time.  (Probably only
         * happens in the simulator...)
         */
        periods += 1.0;
    }
    /* ... and then add in any full periods that were used. */
    periods +=
        (float)(diff_us - (periods * this->bd_Deadline)) /
        (float)this->bd_Period;
    cout << "nperiods: " << periods << endl;
    if( periods > 1.0 )
    {
        /* We overran the deadline, drop the data periods that were overrun. */
        this->bd_AdviseDrop = ((int)floorf(periods + 0.99)) - 1;
    }

    start_us = this->bd_RUStart.ru_utime.tv_usec;
    start_us += this->bd_RUStart.ru_utime.tv_sec * 1000000;
    end_us = ru_end.ru_utime.tv_usec;
    end_us += ru_end.ru_utime.tv_sec * 1000000;
    diff_us = end_us - start_us;
    try
    {
        /* Send our report to the advocate. */
        this->bd_Advocate->ReportCPU(this->bd_Advocate.in(), diff_us, diff_us);
    }
    catch(Broker::InvalidStatus &is)
    {
        cout << "Exception: " << is << endl;
        exit(1);
    }
    catch(CORBA::SystemException &se)
    {
        cout << "CORBA Exception: " << se << endl;
        exit(1);
    }
    catch(...)
    {
        cout << "Unhandled exception" << endl;
    }
}

---