SimNetwork.cpp

Go to the documentation of this file.

#include "SimNetwork.h"
#include "WiringMethodSelector.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <iostream>
using std::cerr;
using std::endl;

//SimNetwork::SimNetwork( MPI::Intracomm &mpiCommunicator, SimParameter sp, DistributionStrategy::DistributionFunction &df )
SimNetwork::SimNetwork( MPI::Intracomm &mpiCommunicator, SimParameter sp, DistributionStrategy::DistributionFunction* df )
        :     simParam(sp),
        distributionStrategy( df ),
        _mpi_rank( mpiCommunicator.Get_rank() ),
        _mpi_size( mpiCommunicator.Get_size() ),
        initialized(false),
        reseted(false),
        _nSpikeMessages(0),
        _nAnalogMessages(0)
{
    wiringMethods = new WiringMethodSelector(this);
    PCSIM::init();
}


SimNetwork::~SimNetwork()
{
    delete wiringMethods;
    delete constructMainRNDEngine;    
    for (size_t i = 0; i < constructIncomingRNGEngines.size() ; ++i) {
        delete constructIncomingRNGEngines[i];
        delete constructOutgoingRNGEngines[i];
    }
    delete objectVariationRNDEngine;
}



SimObject::ID::Vector SimNetwork::add( SimObjectFactory const& model, vector<SimEngine::ID> const& engines )
{
    SimObject::ID::Vector ids( new vector<SimObject::ID::Packed>( engines.size() ) );
    SimObject::ID id;
    for( unsigned i=0; i<engines.size(); i++ ) {
        addObject( model, engines[i], id );
        (*ids)[i] = id.packed();
    }
    return ids;
}


SimObject::ID::Vector SimNetwork::add( const SimObjectFactory &model, const unsigned n)
{
    SimObject::ID::Vector ids( new vector<SimObject::ID::Packed>(n) );
    SimObject::ID id;
    for( unsigned i=0; i<n; i++ ) {
        addObject( model, id );
        (*ids)[i] = id.packed();
    }
    return ids;
}

SimObject::ID::Vector SimNetwork::mount( const SimObjectFactory &model, vector<SimObject::ID::Packed> const& mountpoints, bool collect )
{
    size_t n =  mountpoints.size();
    SimObject::ID::Vector collids( new vector<SimObject::ID::Packed> );
    if( collect ) {
        collids->reserve( n );
        for( size_t i=0; i < n; i++ ) {
            collids->push_back( mount( model, mountpoints[i] ) );
        }
    } else {
        for( size_t i=0; i < n; i++ ) {
            mount( model, mountpoints[i] );
        }
        collids->push_back( (SimObject::ID::Packed)(n) );
    }
    return collids;
}


unsigned  SimNetwork::connect( vector<SimObject::ID::Packed> const& sources, vector<SimObject::ID::Packed> const& destinations, ConnectionIterator & decider )
{
    return wiringMethods->simpleAllToAll().connect(sources, destinations, decider);
}


unsigned  SimNetwork::connect( vector<SimObject::ID::Packed> const& sources, vector<SimObject::ID::Packed> const& destinations, const Time &delay )
{
    return dynamic_cast<OneToOneWiringMethod &>(wiringMethods->oneToOne()).connect(sources, destinations, delay);
}



SimObject::ID::Vector SimNetwork::connect( vector<SimObject::ID::Packed> const& sources, vector<SimObject::ID::Packed> const& destinations, const SimObjectFactory &model, ConnectionIterator & decider, bool collect)
{

    return wiringMethods->simpleAllToAll().connect(sources, destinations, model, decider, collect);
}


SimObject::ID::Vector SimNetwork::connectFast( vector<SimObject::ID::Packed> const& sources, vector<SimObject::ID::Packed> const& destinations, const SimObjectFactory &model, ConnectionIterator & decider, bool collect)
{
    return wiringMethods->distributedAllToAll().connect(sources, destinations, model, decider, collect);
}

uint32 SimNetwork::getUniqueSeedOverMpi( uint32 seed )
{
    return seed;
}

#ifdef _MSC_VER
# pragma warning(disable:4244) // warning C4244: 'initializing' : conversion from 'boost::uint64_t' to 'boost::uint32_t', possible loss of data
# undef min
# undef max
#endif

uint32 SimNetwork::makeSeed( uint32 noiseRNGseed )
{
    uint32 seed = noiseRNGseed;
    if( seed == 0 ) {
        seed = microsec_clock::local_time().time_of_day().total_microseconds();
    }
    return seed ;
}

void SimNetwork::fillSeedVector( uint32 noiseRNGseed, vector<uint32> &sim_seeds )
{
    simRNGSeedGenerator.seed( (boost::uint32_t)noiseRNGseed );
    for( size_t t=0; t<sim_seeds.size(); t++ ) {
        sim_seeds[t] = getSeedFromGenerator();
    }
}

uint32 SimNetwork::getSeedFromGenerator()
{
    return (uint32)( 1.0e9 * ( simRNGSeedGenerator() - simRNGSeedGenerator.min() ) / simRNGSeedGenerator.max() );
}

void SimNetwork::setupConstructRNGEngines()
{

    constructMainRNDEngine = new MersenneTwister19937;
    objectVariationRNDEngine  = new MersenneTwister19937;
    constructIncomingRNGEngines.clear();
    constructOutgoingRNGEngines.clear();
    for (int i = 0; i < _mpi_size ; ++i) {
        constructIncomingRNGEngines.push_back( new MersenneTwister19937 );
        constructOutgoingRNGEngines.push_back( new MersenneTwister19937 );
    }

    uint32 unique_seed = getUniqueSeedOverMpi( makeSeed( simParam.constructionRNGSeed ) );
    constructMainRNDEngine->seed( unique_seed );
    objectVariationRNDEngine->seed( unique_seed );
    simRNGSeedGenerator.seed( unique_seed );

    for (int i = 0; i < _mpi_size ; ++i) {
        constructIncomingRNGEngines[i]->seed( simParam.constructionRNGSeed );
        constructOutgoingRNGEngines[i]->seed( simParam.constructionRNGSeed );
    }
    
    uint32 s;
    for( int a = 0; a < _mpi_size; a ++ ) {
        for( int b = 0; b < _mpi_size; b ++ ) {
            s = getSeedFromGenerator();
            if( a == _mpi_rank ) {
                constructIncomingRNGEngines[ b ]->seed( s );
            }
            if( b == _mpi_rank ) {
                constructOutgoingRNGEngines[ a ]->seed( s );
            }
        }
    }
}

#ifdef _MSC_VER
# pragma warning(default:4244) // warning C4244: 'initializing' : conversion from 'boost::uint64_t' to 'boost::uint32_t', possible loss of data
#endif

---