testScheduling.cpp File Reference

#include "header.h"
#include "testScheduling.h"
#include "Clock.h"
#include "SparseMatrix.h"
#include "SparseMsg.h"
#include "SingleMsg.h"
#include "../builtins/Arith.h"
#include "../shell/Shell.h"

Include dependency graph for testScheduling.cpp:

Go to the source code of this file.

Functions
void	testClock ()
void	testClockMessaging ()
void	testMpiScheduling ()
void	testScheduling ()
void	testSchedulingProcess ()

Variables
static DestFinfo	processFinfo ("process","handles process call", new EpFunc1< TestSched, ProcPtr >(&TestSched::process))
static const Cinfo *	testSchedCinfo = TestSched::initCinfo()

Function Documentation

void testClock

(

)

Check that clock scheduling works.

Definition at line 80 of file testScheduling.cpp.

References Clock::activeTicks_, Clock::buildTicks(), Eref::data(), Shell::doAddMsg(), doubleEq(), Id::eref(), Clock::getCurrentTime(), Clock::handleReinit(), Clock::handleStart(), Id::nextId(), Clock::numTicks, Field< A >::set(), LookupField< L, A >::set(), and Clock::ticks_.

Referenced by testScheduling().

{
    const double runtime = 20.0;
    Id clock(1);

    bool ret = Field< double >::set( clock, "baseDt", 1.0);
    assert( ret );
    ret = LookupField< unsigned int, double >::set( clock, "tickDt", 0, 2.0);
    assert( ret );
    ret = LookupField< unsigned int, double >::set( clock, "tickDt", 3, 1.0);
    assert( ret );
    ret = LookupField< unsigned int, double >::set( clock, "tickDt", 1, 2.0);
    assert( ret );
    ret = LookupField< unsigned int, double >::set( clock, "tickDt", 2, 5.0);
    assert( ret );
    ret = LookupField< unsigned int, double >::set( clock, "tickDt", 4, 3.0);
    assert( ret );
    ret = LookupField< unsigned int, double >::set( clock, "tickDt", 7, 5.0);
    assert( ret );

    /*
    Id tabid = Id::nextId();
    Element* tse = new Element( tsid, testSchedCinfo, "tse", 1 );

    Eref ts( tse, 0 );

    FuncId f( processFinfo.getFid() );
    const Finfo* proc0 = clock.element()->cinfo()->findFinfo( "process0" );
    assert( proc0 );
    const SrcFinfo* sproc0 = dynamic_cast< const SrcFinfo* >( proc0 );
    assert( sproc0 );
    unsigned int b0 = sproc0->getBindIndex();
    SingleMsg *m0 = new SingleMsg( er0.eref(), ts );
    er0.element()->addMsgAndFunc( m0->mid(), f, er0.dataId.value()*2 + b0);
    SingleMsg *m1 = new SingleMsg( er1.eref(), ts );
    er1.element()->addMsgAndFunc( m1->mid(), f, er1.dataId.value()*2 + b0);
    SingleMsg *m2 = new SingleMsg( er2.eref(), ts );
    er2.element()->addMsgAndFunc( m2->mid(), f, er2.dataId.value()*2 + b0);
    SingleMsg *m3 = new SingleMsg( er3.eref(), ts );
    er3.element()->addMsgAndFunc( m3->mid(), f, er3.dataId.value()*2 + b0);
    SingleMsg *m4 = new SingleMsg( er4.eref(), ts );
    er4.element()->addMsgAndFunc( m4->mid(), f, er4.dataId.value()*2 + b0);
    SingleMsg *m5 = new SingleMsg( er5.eref(), ts );
    er5.element()->addMsgAndFunc( m5->mid(), f, er5.dataId.value()*2 + b0);



    assert( cdata->tickPtr_[0].mgr()->ticks_[0] == reinterpret_cast< const Tick* >( er3.data() ) );
    assert( cdata->tickPtr_[1].mgr()->ticks_[0] == reinterpret_cast< const Tick* >( er2.data() ) );
    assert( cdata->tickPtr_[1].mgr()->ticks_[1] == reinterpret_cast< const Tick* >( er1.data() ) );
    assert( cdata->tickPtr_[2].mgr()->ticks_[0] == reinterpret_cast< const Tick* >( er4.data() ) );
    assert( cdata->tickPtr_[3].mgr()->ticks_[0] == reinterpret_cast< const Tick* >( er0.data() ) );
    assert( cdata->tickPtr_[3].mgr()->ticks_[1] == reinterpret_cast< const Tick* >( er5.data() ) );
    */

    Eref clocker = clock.eref();
    Clock* cdata = reinterpret_cast< Clock* >( clocker.data() );
    assert ( cdata->ticks_.size() == Clock::numTicks );
    cdata->buildTicks( clocker );
    assert( cdata->activeTicks_.size() == 0 ); // No messages

    // Now put in the scheduling tester and messages.
    Id test = Id::nextId();
    Element* teste = new GlobalDataElement( test, testSchedCinfo, "test", 1 );
    assert( teste );
    Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );

    shell->doAddMsg( "oneToAll", clock, "process0", test, "process" );
    shell->doAddMsg( "oneToAll", clock, "process1", test, "process" );
    shell->doAddMsg( "oneToAll", clock, "process2", test, "process" );
    shell->doAddMsg( "oneToAll", clock, "process3", test, "process" );
    shell->doAddMsg( "oneToAll", clock, "process4", test, "process" );
    shell->doAddMsg( "oneToAll", clock, "process7", test, "process" );
    // clock.element()->digestMessages();
    cdata->handleReinit( clocker );
    assert( cdata->activeTicks_.size() == 6 ); // No messages
    assert( cdata->activeTicks_[0] == 2 );
    assert( cdata->activeTicks_[1] == 2 );
    assert( cdata->activeTicks_[2] == 5 );
    assert( cdata->activeTicks_[3] == 1 );
    assert( cdata->activeTicks_[4] == 3 );
    assert( cdata->activeTicks_[5] == 5 );
    cdata->handleStart( clocker, runtime, false );
    assert( doubleEq( cdata->getCurrentTime(), runtime ) );
    test.destroy();
    for ( unsigned int i = 0; i < Clock::numTicks; ++i )
        cdata->ticks_[i] = 0;
    cdata->buildTicks( clocker );
    cout << "." << flush;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void testClockMessaging

(

)

Definition at line 171 of file testScheduling.cpp.

References Eref::data(), Shell::doCreate(), Shell::doDelete(), and Id::eref().

Referenced by testScheduling().

{
    Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );
    // Clock* cdata = reinterpret_cast< Clock* >( Id(1).eref().data() );
    Id syns = shell->doCreate( "SimpleSynHandler", Id(), "syns0", 10 );
    Id fire = shell->doCreate( "IntFire", Id(), "fire0", 10 );

    shell->doDelete( syns );
    shell->doDelete( fire );
    cout << "." << flush;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void testMpiScheduling

(

)

Definition at line 193 of file testScheduling.cpp.

Referenced by mpiTests().

{
}

Here is the caller graph for this function:

void testScheduling

(

)

Definition at line 183 of file testScheduling.cpp.

References testClock(), and testClockMessaging().

Referenced by nonMpiTests().

{
    testClockMessaging();
    testClock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void testSchedulingProcess

(

)

Definition at line 189 of file testScheduling.cpp.

Referenced by processTests().

{
}

Here is the caller graph for this function:

Variable Documentation

DestFinfo processFinfo("process","handles process call", new EpFunc1< TestSched, ProcPtr >(&TestSched::process))

static

Referenced by TestSched::initCinfo(), and testFinfoFields().

const Cinfo* testSchedCinfo = TestSched::initCinfo()

static

Definition at line 52 of file testScheduling.cpp.

Referenced by TestSched::initCinfo().