rk_task_good.cc

Go to the documentation of this file.

/*
 * rk_task_good.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 rk_task_good.cc
 *
 * Test the RKTask class.
 */

#include "config.h"

/* Make sure assert is on */
#if !defined(DEBUG)
#define DEBUG 1
#undef NDEBUG
#endif

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

#include <time_util.h>
#include <timesFile.h>

#include <rk_stub.h>

#include <iostream>

#include <RKTask.hh>
#include <ManagerImpl.hh>

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

    assert(tfMakeTimesFile("test_cpu_times",
                           (const float[]){ 50.0, TIMES_FILE_TERMINATOR }));

    /* 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();

    /* Broker setup */
    Broker::ScheduleParameters sp;
    Broker::RealTimeTask_var rtt;
    Broker::Manager_var manager;
    Broker::TaskParameters tp;
    Broker::Task_var task;
    pid_t client_pid;

    client_pid = rk_stub_mk_pid("foo", NULL, NULL, NULL);

    ManagerImpl *mi = new ManagerImpl("manager");

    manager = mi->_this();

    /* Test the constructor */
    tp.length(1);
    tp[0].name = "name";
    tp[0].value <<= "test";

    RKTask *rkt = new RKTask(tp);

    task = rkt->_this();
    rtt = Broker::RealTimeTask::_narrow(task.in());
    assert(!CORBA::is_nil(rtt.in()));

    /* ... change CPU time outside of scheduling */
    assert(rtt->GetComputeTime() != 0);
    rtt->SetComputeTime(250);
    assert(rtt->GetComputeTime() == 250);
    
    sp.length(2);
    sp[0].name = "period";
    sp[0].value <<= "1000";
    sp[1].name = "pid";
    sp[1].value <<= client_pid;

    rtt->SetManager(manager.in());
    
    /* ... begin CPU scheduling */
    rtt->BeginCPUScheduling(sp);

    assert(rtt->Period() == 1000);
    assert(rtt->Deadline() == 1000);
    assert(rtt->GetComputeTime() == 250);

    {
        struct cpu_reserve_attr cra;
        rk_resource_set_t rs;
        rk_reserve_t cr;

        /* Make sure the initial values made it all the way down to the rk. */
        assert((rs = rk_proc_get_rset(client_pid)) != NULL);
        cr = rk_resource_set_get_cpu_rsv(rs);
        rk_cpu_reserve_get_attr(cr, &cra);
        assert(timespec_to_microsec(&cra.period) == 1000);
        assert(timespec_to_microsec(&cra.deadline) == 1000);
        assert(timespec_to_microsec(&cra.compute_time) == 250);

        /* ... and do the same for dynamic changes. */
        rtt->SetComputeTime(500);
        assert(rtt->GetComputeTime() == 500);
        rk_cpu_reserve_get_attr(cr, &cra);
        assert(timespec_to_microsec(&cra.compute_time) == 500);
        rtt->SetComputeTime(250);
    }

    /* ... stop and */
    rtt->EndCPUScheduling();
    
    assert(rtt->GetComputeTime() == 250);

    sp.length(3);
    sp[0].name = "period";
    sp[0].value <<= "1000";
    sp[1].name = "deadline";
    sp[1].value <<= "500";
    sp[2].name = "pid";
    sp[2].value <<= client_pid;

    /* ... restart scheduling */
    rtt->BeginCPUScheduling(sp);
    
    assert(rtt->GetComputeTime() == 250);
    assert(rtt->Period() == 1000);
    assert(rtt->Deadline() == 500);

    rtt->EndCPUScheduling();
    
    return( retval );
}

---