DistributedSimEngine.cpp

Go to the documentation of this file.

#include "DistributedSimEngine.h"
#include "SimNetwork.h"
#include <iostream>

using std::cerr;
using std::cout;
using std::endl;


DistributedSimEngine::DistributedSimEngine(SimEngine &localEngine,
        DistributedIncomingSpikeScheduler &incomingScheduler,
        SpikeScheduler &spikeScheduler,
        DistributedCycledAnalogMsgDispatcher &distCycledAnalogMsgDispatcher,
        MPIAllToAllCommunicator &mpiCommunicator,
        SimNetwork &net) :
        SimEngine((int)0,spikeScheduler,net), localEng(localEngine), inScheduler(incomingScheduler),
        _mpiCommunicator(mpiCommunicator), distCycledAnalogMsgDispatcher(distCycledAnalogMsgDispatcher)
{
    currentStepWithinCycle = 0;
}

DistributedSimEngine::~DistributedSimEngine()
{}

void DistributedSimEngine::advance(int numSteps)
{
    int nCycles;
    int reminderSteps;
    int interval = default_steps_per_cycle ;
    int leftStepsToFinishPreviousCycle;


    if (currentStepWithinCycle) {
        if (numSteps + currentStepWithinCycle >= interval) {
            leftStepsToFinishPreviousCycle = default_steps_per_cycle - currentStepWithinCycle;
            localEng.advanceSeveralStepsWithinACycle(leftStepsToFinishPreviousCycle);
            localEng.finalizeCycle();
            bool finished = false;
            // do complete exchange and then process input buffer
            while (!finished) {                 
                finished = _mpiCommunicator.doAllToAllExchange();
                inScheduler.processMPIInputSpikeBuffers();
            }
            distCycledAnalogMsgDispatcher.dispatchDelayerCycledIncomingAnalogMsgs();
        } else {
            leftStepsToFinishPreviousCycle = numSteps;
            localEng.advanceSeveralStepsWithinACycle(leftStepsToFinishPreviousCycle);
        }
        numSteps -= leftStepsToFinishPreviousCycle;
    }

    reminderSteps = numSteps % interval;
    nCycles = (numSteps - reminderSteps) / interval;


    for (int c = 0 ; c < nCycles ; ++c ) {
        localEng.advanceOneFullCycle();
        bool finished = false;
        // do complete exchange and then process input buffer        
        while (!finished) {
            finished = _mpiCommunicator.doAllToAllExchange();
            inScheduler.processMPIInputSpikeBuffers();
        }
        
        distCycledAnalogMsgDispatcher.dispatchDelayerCycledIncomingAnalogMsgs();
    }

    if (reminderSteps > 0 ) {
        localEng.advanceSeveralStepsWithinACycle(reminderSteps);
        // do complete exchange and process input buffer interchangeably
        bool finished = false;
        while (!finished) {             
            finished = _mpiCommunicator.doAllToAllExchange();
            inScheduler.processMPIInputSpikeBuffers();
        }
        distCycledAnalogMsgDispatcher.dispatchDelayerCycledIncomingAnalogMsgs();
    }
    currentStepWithinCycle = reminderSteps;

}


void DistributedSimEngine::advanceSeveralStepsWithinACycle(int nsteps)
{
    localEng.advanceSeveralStepsWithinACycle(nsteps);
}

void DistributedSimEngine::advanceOneFullCycle()
{
    localEng.advanceOneFullCycle();
    bool finished = false;
    // do complete exchange and then process input buffer
    while (!finished) {
        finished = _mpiCommunicator.doAllToAllExchange();
        inScheduler.processMPIInputSpikeBuffers();
    }
    distCycledAnalogMsgDispatcher.dispatchDelayerCycledIncomingAnalogMsgs();
}

void DistributedSimEngine::finalizeCycle()
{
    localEng.finalizeCycle();
    bool finished = false;
    // do complete exchange and then process input buffer
    while (!finished) {
        finished = _mpiCommunicator.doAllToAllExchange();
        inScheduler.processMPIInputSpikeBuffers();
    }
    distCycledAnalogMsgDispatcher.dispatchDelayerCycledIncomingAnalogMsgs();
}

void DistributedSimEngine::reset()
{
    localEng.reset();
    currentStepWithinCycle = 0;
}

void DistributedSimEngine::initialize()
{
    localEng.initialize();
}

void DistributedSimEngine::addObject( SimObjectFactory const& objFactory, SimObject::ID &id )
{
    localEng.addObject(objFactory, id);
}

void DistributedSimEngine::mount( const SimObjectFactory &objFactory, const SimObject::ID &mountpoint, SimObject::ID &gid )
{
    localEng.mount( objFactory, mountpoint, gid );
}

void DistributedSimEngine::insert( const SimObjectFactory &objFactory, const SimObject::ID &mountpoint, SimObject::ID &gid )
{
    localEng.insert( objFactory, mountpoint, gid );
}

SimObject *DistributedSimEngine::getObject(const SimObject::ID &id)
{
    return localEng.getObject(id);
}

---