SingleThreadNetwork.cpp

Go to the documentation of this file.

#include "SingleThreadNetwork.h"
#include "SpikeSender.h"
#include "PCSIMException.h"
#include "RandomDistribution.h"

#include <boost/format.hpp>

#include <string>
using std::string;

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

// ------------------------------ constructor  / destructor --------------------------------------- //

SingleThreadNetwork::SingleThreadNetwork( SimParameter sp ) :
        SimNetwork(MPI::COMM_WORLD, sp, &localRoundRobin)
{
    init();
}

SingleThreadNetwork::SingleThreadNetwork(MPI::Intracomm &comm, SimParameter sp ) :
        SimNetwork(comm, sp, &localRoundRobin)
{
    init();
}

void SingleThreadNetwork::init()
{
    spikeBuffer = new PropagatedSpikeBuffer(simParam.minDelay.in_steps( get_dt() ), simParam.maxDelay.in_steps( get_dt() ) );
    delayMap = new LocalDelayMap;
    stgPool = new SpikeTargetGroupPool;
    spikeScheduler = new SingleThreadSpikeScheduler(*delayMap, *stgPool, *spikeBuffer, simParam ) ;
    analogMsgDispatcher = new SingleThreadAnalogMsgDispatcher;
    simEngine = new SingleThreadSimEngine(0, *spikeScheduler, *analogMsgDispatcher, *this );
    analogDelayObjectsMap = new AnalogDelayObjectMap;

    analogMsgCreator = new STAnalogMessageCreator(*analogMsgDispatcher,
                       *simEngine,
                       *analogDelayObjectsMap,
                       (delay_t)simParam.minDelay.in_steps( get_dt() ) );


    setupConstructRNGEngines();
    SingleThreadNetwork::seed_noise_rng( makeSeed( simParam.simulationRNGSeed ) );
 
}

SingleThreadNetwork::~SingleThreadNetwork()
{
    delete spikeBuffer;
    delete delayMap;
    delete spikeScheduler;
    delete simEngine;
    delete stgPool;
    delete analogMsgDispatcher;
    delete analogMsgCreator;
    if (!initialized) {
        delete analogDelayObjectsMap;
    }
}

void SingleThreadNetwork::seed_noise_rng( uint32 noiseRNGseed )
{
    simEngine->seed( noiseRNGseed );
    objectVariationRNDEngine->seed( makeSeed( simParam.constructionRNGSeed ) ) ;
}

// ------------------------- adding objects ----------------------- //

/*void SingleThreadNetwork::addObject(SimObject * o, SimObject::ID &id)
{
    id.node    = _mpi_rank;
    id.eng     = 0;
    id.type    = o->getObjectTypeID();
    simEngine->addObject( o, id );
}
 
void SingleThreadNetwork::addObject( SimObject *obj, const engineid_t eng, SimObject::ID &id)
{
    if( eng == 0 ) {
        addObject( obj, id );
    } else {
        id = SimObject::ID::Invalid;
        throw( PCSIM::ConstructionException( "SingleThreadNetwork::addObject", str( boost::format("Specified engine (%1%) out of range.") % eng) ) );
    }
} */

void SingleThreadNetwork::_addObject_( const SimObjectFactory &objFactory, const SimEngine::ID &loc, SimObject::ID &oid )
{
    if( loc.node == _mpi_rank && loc.engine == 0 ) {
        addObject( objFactory, oid );
    } else {
        // cerr << boost::format("Specified node (%1%) does not match mpi rank (%2%)") % loc.node % _mpi_rank << endl;
        oid = SimObject::ID::Invalid;
        if( loc.node != _mpi_rank )
            throw( PCSIM::ConstructionException( "SingleThreadNetwork::addObject", str( boost::format("Specified node (%1%) does not mach mpi rank (%2%)") % loc.node % _mpi_rank ) ) );
        else
            throw( PCSIM::ConstructionException( "SingleThreadNetwork::addObject", str( boost::format("Specified engine (%1%) not zero") % loc.engine ) ) );
    }
}

void SingleThreadNetwork::_addObject_( const SimObjectFactory &objFactory, SimObject::ID &gid )
{
    simEngine->addObject( objFactory, gid );
    gid.node    = _mpi_rank;
    gid.eng     = 0;
}

void SingleThreadNetwork::_mount_( const SimObjectFactory &objFactory, const SimObject::ID &mountpoint, SimObject::ID &gid )
{
    simEngine->mount( objFactory, mountpoint, gid );
    gid.node    = _mpi_rank;
    gid.eng     = 0;
}

void SingleThreadNetwork::_insert_( const SimObjectFactory &objFactory, const SimObject::ID &container, SimObject::ID &gid )
{
    simEngine->insert( objFactory, container, gid );
    gid.node    = _mpi_rank;
    gid.eng     = 0;
}

SimObject * SingleThreadNetwork::_getObject_(const SimObject::ID &id)
{
    return simEngine->getObject(id);
}


// ----------------------------------  connections ---------------------------------------- //

void SingleThreadNetwork::_connect_( SimObject::ID const& src, port_t out, const SimObject::ID &dst, port_t in, int delay )
{
    SimObject *src_obj = simEngine->getObject(src);
    SimObject *dst_obj = simEngine->getObject(dst);

    // SpikeSender     *ss;

    Time delay_to_use;
    if( delay < 0 ) {
        delay_to_use = Time::sec( dst_obj->getManagedDelay() );
    } else {
        delay_to_use = Time::steps( delay, get_dt() );
    }

    if( src_obj->outputPortType(out) == SimObject::spiking && dst_obj->inputPortType( in ) == SimObject::spiking ) {
        addSpikeMessage( src, out, dst, in, delay_to_use );
    } else if ( src_obj->outputPortType(out) == SimObject::analog && dst_obj->inputPortType( in ) == SimObject::analog ) {
        addAnalogMessage( src, out, dst, in, delay_to_use );
    } else {
        cerr << " output port = " << int(src_obj->outputPortType(out)) << " input port " << in << " = " << int(dst_obj->inputPortType( in )) << " spiking constant = " << int(SimObject::spiking) << endl;
        throw( PCSIM::ConstructionException(
                   "SingleThreadNetwork::_connect_",
                   str( boost::format("Can not connect specified source (%1%) and destination object (%2%): no matching in (%3%) and out (%4%) ports.") % src.toString() % dst.toString() % in % out )
               ) );
    }
}

// ---------------------------------- spike messages -------------------------------------- //

void SingleThreadNetwork::_addSpikeMessage_(const SimObject::ID &sender, const port_t out, const SimObject::ID &receiver, const port_t in_port, const Time &delay)
{
    if( delay > simParam.maxDelay ) {
        throw( PCSIM::ConstructionException( "SingleThreadNetwork::addSpikeMessage", str( boost::format("Specified delay (%1% ms) larger then maximum delay (%2% ms)") % delay.in_ms() % simParam.maxDelay.in_ms() ) ) );
    }

    SimObject *src_obj = simEngine->getObject(sender);
    SpikeSender *ss = dynamic_cast<SpikeSender*>( src_obj );

    if( ss == NULL ) {
        throw( PCSIM::ConstructionException( "SingleThreadNetwork::addSpikeMessage", str( boost::format("Specified simulation object (%1%,%2%) is not a spike sender.") % sender.toString() % typeid(*src_obj).name() ) ) );
    }

    if( ss->getSpikePort( out ) != NULL ) {
        addLocalSpikeMessage( delayMap, stgPool, simEngine, ss->getSpikePort( out )->ID(), receiver, in_port, delay.in_steps( get_dt() ) );
        _nSpikeMessages++;
    } else {
        throw(
            PCSIM::ConstructionException (
                "SingleThreadNetwork::addSpikeMessage",
                str( boost::format("Specified spike output port (%1%) of %s with ID=%2% does not exist") % out % typeid(*src_obj).name() % sender.toString() )
            )
        );
    }
}

void SingleThreadNetwork::addLocalSpikeMessage(
    LocalDelayMap *arg_delayMap, SpikeTargetGroupPool *arg_stgPool, SimEngine *arg_simEng,
    const spike_port_id_t sender_port, const SimObject::ID &receiver, port_t in_port, step_t delay )
{
    SimObject       *rec_obj    = arg_simEng->getObject(receiver);
    spikegroupid_t   tg          = arg_delayMap->find(sender_port, (delaystep_t)delay);
    if( tg == no_spikegroup ) {
        tg = arg_stgPool->addSpikeTarget( rec_obj, in_port ); // receiver, port
        arg_delayMap->insert( sender_port, (delaystep_t)delay, tg ); // sender_port, delay, targetgroup
    } else {
        arg_stgPool->addSpikeTarget( tg, rec_obj, in_port);
    }
}

// ------------------------------------ analog messages -------------------------------------- //

void SingleThreadNetwork::_addAnalogMessage_(const SimObject::ID &sender, int sender_port, const SimObject::ID &receiver, int recv_port, const Time &delay)
{
    _nAnalogMessages++;
    analogMsgCreator->addAnalogMessage(sender, sender_port, receiver, recv_port, (delay_t)delay.in_steps( get_dt() ) );
}
//
void SingleThreadNetwork::_addAnalogMessage_(const SimObject::ID &sender, int sender_port, const SimObject::ID &receiver, string destfield, const Time &delay)
{
    _nAnalogMessages++;
    analogMsgCreator->addAnalogMessage(sender, sender_port, receiver, destfield, (delay_t)delay.in_steps( get_dt() ) );
}

void SingleThreadNetwork::_addAnalogMessage_(const SimObject::ID &sender, string srcfield, const SimObject::ID &receiver, int recv_port, const Time &delay)
{
    _nAnalogMessages++;
    analogMsgCreator->addAnalogMessage(sender, srcfield, receiver, recv_port, (delay_t)delay.in_steps( get_dt() ) );
}

void SingleThreadNetwork::_addAnalogMessage_(const SimObject::ID &sender, string srcfield, const SimObject::ID &receiver, string destfield, const Time &delay)
{
    _nAnalogMessages++;
    analogMsgCreator->addAnalogMessage(sender, srcfield, receiver, destfield, (delay_t)delay.in_steps( get_dt() ) );
}

// -------------------------- running the simulation messages -------------------------------- //

void SingleThreadNetwork::_initialize_()
{
    if (!initialized) {
        simEngine->initialize();
        delete analogDelayObjectsMap;
        initialized = true;
    }
}

void SingleThreadNetwork::_reset_()
{
    if( ! initialized ) initialize();
    spikeScheduler->reset();
    simEngine->reset();
    reseted = true;
}

void SingleThreadNetwork::_advance_( int nSteps )
{
    if( ! reseted ) reset();
    simEngine->advance( nSteps );
}

---