SingleThreadSimEngine.cpp

Go to the documentation of this file.

#include "SingleThreadSimEngine.h"

#include "SpikeSender.h"
#include "SimNetwork.h"
#include "SimObjectRegistry.h"

#include <algorithm>
using std::make_heap;
using std::sort_heap;

#include <iostream>
using std::cout;
using std::endl;
using std::cerr;

SingleThreadSimEngine::SingleThreadSimEngine(int ID, SpikeScheduler &scheduler, AnalogMessageDispatcher &analogMsgDispatcher, SimNetwork &net):
        SimEngine(ID,scheduler, net),
        activeSpikeReceiver(0), t( Time::ms(0) ), step(0),  dtHasChanged(false),
        initialized(false),
        isReset(false),
        objectListsDirty(true),
        analog_msg_dispatcher(analogMsgDispatcher),
        objPool(20),
        nSpikeOutputPorts(0)
{
    // srng = new SimpleRandomNumberGenerator;
    noiseRNDEngine = new ThreadSpecificRandomEngineType;
    noiseRNDEngine->seed( net.simParameter().simulationRNGSeed );
    //SimObject::setSimEngine( this );
}

SingleThreadSimEngine::~SingleThreadSimEngine()
{
        theThreadSpecificRandomEngine.unset( noiseRNDEngine );
    delete noiseRNDEngine;
}

void SingleThreadSimEngine::seed( vector<uint32> const& noiseSeed )
{
    noiseRNDEngine->seed( noiseSeed[0] );
}

void SingleThreadSimEngine::seed( uint32 noiseSeed )
{
    noiseRNDEngine->seed( noiseSeed );
}

void SingleThreadSimEngine::addObject( SimObjectFactory const& objFactory, SimObject::ID &id )
{
    objectListsDirty = true;
    id.type = objFactory.getObjectTypeID();
    id.localid = objPool.addObject( objFactory, network.getObjectVariationRNDEngine() );
    addSpikePorts( objPool.getObject( id.type, id.localid ), id );    
}

void SingleThreadSimEngine::addSpikePorts( SimObject *obj, SimObject::ID &id )
{
    SingleOutputSpikeSender *single_out = dynamic_cast< SingleOutputSpikeSender *>( obj );
    if( single_out != NULL ) {
        single_out->getSpikePort()->setID( (spike_port_id_t)nSpikeOutputPorts );
        nSpikeOutputPorts++;
    } else {
        MultipleOutputSpikeSender *multi_out = dynamic_cast< MultipleOutputSpikeSender *>( obj );
        if( multi_out != NULL ) {
            for( int p = 0; p < ( obj->nSpikeOutputPorts() + obj->nAnalogOutputPorts() ); p++ ) {
                if( obj->outputPortType( p ) == SimObject::spiking ) {
                    multi_out->getSpikePort(p)->setID( nSpikeOutputPorts );
                    nSpikeOutputPorts++;
                }
            }
        }
    }
}

void SingleThreadSimEngine::mount( const SimObjectFactory &objFactory, const SimObject::ID &mountpoint, SimObject::ID &gid )
{
    addObject( objFactory, gid );
    one_way_link( gid, mountpoint );
}

void SingleThreadSimEngine::insert( const SimObjectFactory &objFactory, const SimObject::ID &mountpoint, SimObject::ID &gid )
{
    addObject( objFactory, gid );
    two_way_link( gid, mountpoint );
}

void SingleThreadSimEngine::two_way_link( const SimObject::ID &id1, const SimObject::ID &id2 )
{

    SimObject *obj1 = objPool.getObject( id1.type, id1.localid );
    SimObject *obj2 = objPool.getObject( id2.type, id2.localid );

    obj1->incoming( obj2, id2, id1, network );
    obj2->outgoing( obj1, id1, id2, network );

    obj2->incoming( obj1, id1, id2, network );
    obj1->outgoing( obj2, id2, id1, network );
}

void SingleThreadSimEngine::one_way_link( const SimObject::ID &src, const SimObject::ID &dst )
{
    SimObject *s = objPool.getObject( src.type, src.localid );
    SimObject *d = objPool.getObject( dst.type, dst.localid );

    d->incoming( s, src, dst, network );
    s->outgoing( d, dst, src, network );
}

void SingleThreadSimEngine::reset()
{
    if (!initialized)
        initialize();
    // register ourselfs at the executing thread
    //SimObject::setSimEngine( this );
    theThreadSpecificRandomEngine.set( noiseRNDEngine );

    // make sure that all objects have consistent internal states
    double dt = network.get_dt().in_sec();
    objPool.updateObjects( dtHasChanged, dt );

    // reset to t=0
    t = Time::ms(0);
    step = 0;

    // empty list of active synapses
    activeSpikeReceiver.resize(0);

    SimObjectPool::SimObjectIterator oit;
    // reset all elements
    int nTypes = objPool.numOfTypes();
    for( int t = 0; t < nTypes; t++ ) {
        for( oit = objPool.beginObject(t); oit != objPool.endObject(t); ++oit ) {
            if( (*oit)->reset( dt ) & RESETFLAG_ACTIVATE ) {
                activeSpikeReceiver.push_back( *oit );
            };
        }
    }

    // finally say that we did a reset
    isReset = 1;
}

void SingleThreadSimEngine::initialize()
{

    // register ourselfs at the executing thread
    if (!initialized) {
        //SimObject::setSimEngine( this );
        theThreadSpecificRandomEngine.set( noiseRNDEngine );

        SimObjectPool::SimObjectIterator oit;        
        InitializeInfo ii( &network, this );        
        int nTypes = objPool.numOfTypes();
        for( int t = 0; t < nTypes; t++ ) {
            for( oit = objPool.beginObject(t); oit != objPool.endObject(t); ++oit ) {
                (*oit)->init(&ii);
            }
        }
        initialized = true;
    }
}



void SingleThreadSimEngine::advance(int nSteps)
{
    // there must be at least one call to reset!
    if( !isReset ) {
        reset();
    }

    // register ourselfs at the executing thread
    //SimObject::setSimEngine( this );
    theThreadSpecificRandomEngine.set( noiseRNDEngine );

    SimObjectPool::SimObjectIterator oit;

    int type;

    AdvanceInfo adv_inf( &network, this );

    for( int s=0; s<nSteps; s++ ) {

        adv_inf.t = this->t;

        // A) Do analog messages dispatching first
        analog_msg_dispatcher.dispatchAnalogMsgs();

        // B) ADVANCE_PHASE_1: Advance all objects scheduled before potential event driven objects
        for( type = 0; type < SimObjectRegistry::FirstIndexOf::SpikeDriven ; type++ ) {
            for( oit = objPool.beginObject(type); oit != objPool.endObject(type); ++oit ) {
                (*oit)->advance(adv_inf);
            }
        }
        
        // C) Deliver the spikes to their targets
        spikeScheduler.deliverSpikes( activeSpikeReceiver, this->eid, t.in_sec() );

        // D) SPIKE DRIVEN: advance the vector of active sim objects
        size_t i=0;
        while( i < activeSpikeReceiver.size() ) {
            // if advance() & ADVANCEFLAG_DEACTIVATE > 0
            if( activeSpikeReceiver[i]->advance(adv_inf) & ADVANCEFLAG_DEACTIVATE ) {
                activeSpikeReceiver[i] = activeSpikeReceiver.back();
                activeSpikeReceiver.resize( activeSpikeReceiver.size() - 1);
            } else {
                i++;
            }
        }

        // E) ADVANCE_PHASE_2: advance all objects scheduled after potential event driven objects except objetcs with type >= SimObject::TypeID::NoAdvance
        for( type = SimObjectRegistry::FirstIndexOf::AdvancePhase2; type < SimObjectRegistry::FirstIndexOf::NoAdvance; type++ ) {
            for( oit = objPool.beginObject(type); oit != objPool.endObject(type); ++oit ) {
                (*oit)->advance(adv_inf);
            }
        }

        // also the spike scheduler wants to know the clock
        spikeScheduler.advance(eid);

        // increment simulation time from t -> t + dt
        t += network.get_dt();
        step++;

    }

}

void SingleThreadSimEngine::advanceOneFullCycle()
{
    advance(default_steps_per_cycle);
    spikeScheduler.nextCycle();
}

void SingleThreadSimEngine::advanceSeveralStepsWithinACycle(int nsteps)
{
    advance(nsteps);
}

void SingleThreadSimEngine::finalizeCycle() {}

---