basic_test.cc

Go to the documentation of this file.

/*
 * basic_test.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 basic_test.cc
 *
 * Test the 'basic' qosket.
 */

#include "config.h"

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

#include <assert_pp.h>

#include <timesFile.h>

#include <iostream>

#include <rk_stub.h>

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

#include <BasicTaskKernelImpl.h>

#include <StubBasicTaskQosket.hh>
#include <StrictPolicyCallbackImpl.hh>

/**
 * Evaluate the given contract and check that it is in the expected region.
 *
 * @param contract The contract to evaluate/check.
 * @param expected_name The expected region name.
 * @return True if the contract is in the expected region, false otherwise.
 */
static int contract_region(quo::Contract_ptr contract,
                           const char *expected_name)
{
    quo::strings_var result;
    unsigned int lpc;
    int retval = 0;

    require(contract != NULL);
    require(expected_name != NULL);

    contract->eval();
    
    result = contract->getCurrentRegionName();
    for( lpc = 0; lpc < result->length(); lpc++ )
    {
        if( strcmp(result[lpc], expected_name) == 0 )
        {
            retval = 1;
        }
    }
    
    return( retval );
}

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

    rk_stub_set_mode(RK_STUB_LOG);

#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();

    /* QuoKernel setup */
    Qosket::Basic::BasicTaskKernelImpl *btki;
    quo::QuoKernel_var qk;

    btki = new Qosket::Basic::BasicTaskKernelImpl(orb);
    qk = btki->_this();

    /* Build the qosket */
    StubBasicTaskQosket *btqi;
    quo::Contract_var contract;
    quo::ValueSC_var last_status;

    btqi = new StubBasicTaskQosket();
    btqi->initSysconds(qk);
    btqi->initCallbacks(orb);
    contract = btqi->initContract(qk);

    last_status = btqi->LastStatus();

    /* Evaluate the contract under initial conditions. */
    assert(contract_region(contract.in(), "OnTime"));
    /* Check that the callback was called. */
    assert(btqi->btq_Callback->btc_Missed == 0);
    assert(btqi->btq_Callback->btc_Made == 1);

    /* Report a late status and */
    last_status->longValue(11);

#if 0
    /* ... check that the contract switches to the 'Late' region */
    assert(contract_region(contract.in(), "Late"));
    assert(btqi->btq_Callback->btc_Missed == 1);
    assert(btqi->btq_Callback->btc_Made == 1);

    /* Report an on time status and */
    last_status->longValue(10);

    /* ... check that the contract switches back to the 'OnTime' region. */
    assert(contract_region(contract.in(), "OnTime"));
    assert(btqi->btq_Callback->btc_Missed == 1);
    assert(btqi->btq_Callback->btc_Made == 2);
#endif
    
    /* 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
    }));
    
    /* 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();

    Qosket::StrictPolicy::StrictPolicyCallback_var spc;
    StrictPolicyCallbackImpl *spci;

    spci = new StrictPolicyCallbackImpl(policy.in());
    spc = spci->_this();
    
    mi->CurrentPolicy(policy.in());

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

    /* Make the tasks/advocates */
    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);

    assert(spc->GetPriorityOf("c1") == 0);
    
    spc->SetPriorityOf("c1", 5);
    
    assert(spc->GetPriorityOf("c1") == 5);

    try
    {
        spc->GetPriorityOf("c2");

        ensure(0);
    }
    catch(const CORBA::BAD_PARAM &e)
    {
    }
    
    return( retval );
}

---