all_test1.cc

Go to the documentation of this file.

/*
 * all_test1.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 all_test1.cc
 *
 * An all-up test of the CPU broker components.
 */

#include "config.h"

#if !defined(DEBUG)
#define DEBUG 1
#endif

#include <stdlib.h>

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

#include <timesFile.h>

#include <rk.h>
#include <rk_stub.h>

#include <iostream>

#include <BrokerC.h>
#include <StrictPolicyC.h>

#include <ManagerImpl.hh>
#include <BasicDelegate.hh>
#include <RealTimeTaskImpl.hh>

#include <StrictPolicyImpl.hh>

#include <LoggingAdvocate.hh>
#include <MaxDecayTaskAdvocate.hh>
#include <GlacialTaskAdvocate.hh>

int main(int argc, char *argv[])
{
    int retval = EXIT_SUCCESS;

    /* Initialize the simulator */
    rk_stub_set_mode(RK_STUB_SIM);

#if defined(HAVE_ACE)
    /* Put a sock in ACE */
    ACE_Log_Msg::instance()->priority_mask(0, ACE_Log_Msg::PROCESS);
#endif

    /* ORB/POA setup */
    CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
    CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
    
    PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
    PortableServer::POAManager_var mgr = root_poa->the_POAManager();
    mgr->activate();

    /* Create some input files for each process to be simulated. */
    assert(tfMakeTimesFile("c1_cpu_times",
                           (const float[]){
        55.0, /*
               * repeatedly require 55% of the CPU for task one to meet the
               * deadline
               */
        /* Add more values here to change the sequence of CPU requirements */
        TIMES_FILE_TERMINATOR
    }));
    assert(tfMakeTimesFile("c2_cpu_times",
                           (const float[]){
        20.0, /* ... 20% for task two */
        TIMES_FILE_TERMINATOR
    }));
    assert(tfMakeTimesFile("c3_cpu_times",
                           (const float[]){
        20.0, /* ... 20% for task three */
        TIMES_FILE_TERMINATOR
    }));

    /* Broker setup */
    Broker::Manager_var manager;
    ManagerImpl *mi;

    mi = new ManagerImpl("dummy");
    manager = mi->_this();

    BrokerPolicies::StrictPolicy_var policy;
    StrictPolicyImpl *spi;

    spi = new StrictPolicyImpl("StrictPolicy");
    policy = spi->_this();

    mi->CurrentPolicy(policy.in());

    BasicDelegate c1("c1", 10000, 10000);

    /* Make the delegates and, in turn, the fake processes. */
    BasicDelegate c2("c2", 20000, 20000);
    BasicDelegate c3("c3", 10000, 10000);

    /* Make the tasks/advocates */
    RealTimeTaskDelegateImpl *rttdi;
    RealTimeTaskImpl *rtti;

    /* ... for process one */
    rtti = new RealTimeTaskImpl(c1.bd_TaskDescription); 
    c1.bd_Advocate = Broker::RealTimeTask::_narrow(rtti->_this());
    assert(!CORBA::is_nil(c1.bd_Advocate.in()));
    manager->AddTask(c1.bd_Advocate.in(), c1.bd_CPUSchedule);

    /* ... for process two */
    rtti = new RealTimeTaskImpl(c2.bd_TaskDescription);
    c2.bd_Advocate = Broker::RealTimeTask::_narrow(rtti->_this());
    assert(!CORBA::is_nil(c2.bd_Advocate.in()));
    manager->AddTask(c2.bd_Advocate.in(), c2.bd_CPUSchedule);

    /* ... for process three */
    rtti = new RealTimeTaskImpl(c3.bd_TaskDescription);
    rttdi = new GlacialTaskAdvocate();
    rttdi->SetDelegateAttributeObject("remote-object", rtti->_this());
    c3.bd_Advocate = Broker::RealTimeTask::_narrow(rttdi->_this());
    assert(!CORBA::is_nil(c3.bd_Advocate.in()));
    manager->AddTask(c3.bd_Advocate.in(), c3.bd_CPUSchedule);

    /* Start the simulation. */
    struct timespec curr, end = { 1, 0 };

    /* ... stage one, all the same priority */
    do {
        rk_stub_next_tick();
        rk_clock_gettime(CLOCK_REALTIME, &curr);
    } while( curr.tv_sec < end.tv_sec );

    /* ... stage two, bump process two's priority */
    policy->SetTaskPriority(c2.bd_Advocate.in(), 1);

    end.tv_sec = 2;
    
    do {
        rk_stub_next_tick();
        rk_clock_gettime(CLOCK_REALTIME, &curr);
    } while( curr.tv_sec < end.tv_sec );

    /* ... stage three, bump process three's priority */
    policy->SetTaskPriority(c3.bd_Advocate.in(), 1);

    end.tv_sec = 3;
    
    do {
        rk_stub_next_tick();
        rk_clock_gettime(CLOCK_REALTIME, &curr);
    } while( curr.tv_sec < end.tv_sec );

    /* ... stage four, bump process one's priority past the others */
    policy->SetTaskPriority(c1.bd_Advocate.in(), 2);

    end.tv_sec = 4;
    
    do {
        rk_stub_next_tick();
        rk_clock_gettime(CLOCK_REALTIME, &curr);
    } while( curr.tv_sec < end.tv_sec );
    
    return( retval );
}

---