MultiThreadSpikeScheduler.cpp

Go to the documentation of this file.

#include "MultiThreadSpikeScheduler.h"

MultiThreadSpikeScheduler::MultiThreadSpikeScheduler(
    int numThreads,
    MTSpikeRoutingTables &tables,
    vector<PropagatedSpikeBuffer*> &stBuffers,
    SimParameter &sp)
        : _numThreads(numThreads),
        rtables(tables),
        mTDelayMap(tables.mTDelayMap),
        tgtGrpPool(tables.stgPool),
        _simParam(sp),
        STbuffers(stBuffers),
        mTSpikeBuffers(numThreads, sp.minDelay.in_steps( sp.dt ), sp.maxDelay.in_steps( sp.dt ))
{

    int i;

    /* Setup the single threaded schedulers */
    STschedulers.reserve(_numThreads);
    for (i = 0 ; i < _numThreads ; i++ ) {
        SingleThreadSpikeScheduler scheduler(rtables.localDelayMaps[i], tgtGrpPool, *STbuffers[i], _simParam);
        STschedulers.push_back(scheduler);
    }

    nCycleSteps = _simParam.minDelay.in_steps( _simParam.dt );

    engineSteps = new int[_numThreads];
    // reimplement with memset
    for (i = 0 ; i < _numThreads ; i++ ) {
        engineSteps[i] = 0;
    }
}

MultiThreadSpikeScheduler::~MultiThreadSpikeScheduler()
{
    delete [] engineSteps;
}

void MultiThreadSpikeScheduler::scheduleSpike(local_objectid_t localid, float offsetFraction, engineid_t engine)
{
    /* Schedule spike to the single threaded spike scheduler */
    STschedulers[engine].scheduleSpike(localid, offsetFraction);

    //  cout << "new spike localid=" << localid << " engine=" << engine << endl;

    int last_dest_eng = mTDelayMap.lastDestEngine(engine, localid);
    for (int desteng = 0; desteng <= last_dest_eng; ++desteng) {
        NodeLocalMultiTargetDelayMap::const_iterator delay_iter = mTDelayMap.beginDelays(engine, localid, desteng);
        NodeLocalMultiTargetDelayMap::const_iterator delay_end_iter = mTDelayMap.endDelays(engine, localid, desteng);
        while (delay_iter != delay_end_iter) {
            //          cout << "spike added to buffer " << desteng << " " << engine << endl;
            mTSpikeBuffers.buffers[desteng][engine]->scheduleSpikeTargetGroup(delay_iter->second, delay_iter->first + engineSteps[engine], offsetFraction);
            ++delay_iter ;
        }
    }
}

void MultiThreadSpikeScheduler::advance(engineid_t engine)
{
    STschedulers[engine].advance();
    engineSteps[engine] ++;
}

void MultiThreadSpikeScheduler::reset()
{
    // reset the multi-threaded spike buffers
    for (int i = 0; i < _numThreads; ++i ) {
        for (int j = 0; j < _numThreads; ++j ) {
            mTSpikeBuffers.buffers[i][j]->reset(_simParam.minDelay.in_steps( _simParam.dt ), _simParam.maxDelay.in_steps( _simParam.dt ));
        }
        // reimplement with memset?
        engineSteps[i] = 0;

        // reset the Single Threaded Spike schedulers
        STschedulers[i].reset();
    }
}

void MultiThreadSpikeScheduler::nextCycle()
{
    int eSteps = engineSteps[0] ;
    for (int i = 0; i < _numThreads; ++i ) {
        for (int j = 0; j < _numThreads; ++j ) {
            // advance the buffers for the already processed time steps (contained in engineSteps[i]
            // After the end of one cycle every member of engineSteps should be the same
            for (int k = 0 ; k < eSteps ; ++k ) {
                //      cout << "buffers["<< i << ", " << j << "].nextTimeStep" << endl;
                mTSpikeBuffers.buffers[i][j]->nextTimeStep();
            }
        }
        // reimplement with memset?
        engineSteps[i] = 0;
    }
}

void MultiThreadSpikeScheduler::deliverSpikes(SpikeReceiverList &listActiveSynapses,
        engineid_t engine = 0, double simTime = -1, int stepOffset)
{
    PropagatedSpikeBuffer::const_iterator srg_iter;
    PropagatedSpikeBuffer::const_iterator srg_iter_end;

    SpikeTargetGroupPool::const_iterator target_syn_iter;
    SpikeTargetGroupPool::const_iterator target_syn_iter_end;

    STschedulers[engine].deliverSpikes(listActiveSynapses, engine, simTime, stepOffset);

        SpikeEvent spike( simTime, 1.0, 1.0, _simParam.dt );

    for (int srceng = 0 ; srceng < _numThreads ; ++srceng) {

        srg_iter_end = mTSpikeBuffers.buffers[engine][srceng]->endSpikeTargetGroups(stepOffset+engineSteps[engine]);
        for (srg_iter = mTSpikeBuffers.buffers[engine][srceng]->beginSpikeTargetGroups(stepOffset+engineSteps[engine]);
                srg_iter != srg_iter_end; ++srg_iter) {

            target_syn_iter_end = tgtGrpPool.endSpikeTargetGroup(*srg_iter);
            for (target_syn_iter = tgtGrpPool.beginSpikeTargetGroup(*srg_iter); target_syn_iter != target_syn_iter_end; ++target_syn_iter ) {
                //      cout << "spike delivered simTime=" << simTime << "engine=" << engine << " srceng=" << srceng <<
                //         " engineSteps=" << engineSteps[engine] << endl;
                spike.delta = _simParam.dt.in_sec() * srg_iter->offsetFraction;
                if( ( target_syn_iter->receiver->spikeHit( target_syn_iter->port, spike ) ) & SPIKEHITFLAG_ACTIVATE ) {
                    listActiveSynapses.push_back( target_syn_iter->receiver );
                    SimObject *obj = target_syn_iter->receiver;
                        while ( (obj = obj->getChainedObject()) != NULL) {
                        if (obj->toBeActivated()) listActiveSynapses.push_back( obj );
                        }
                }
            }
        }
    }
}

---