MultiThreadSimEngine.h

Go to the documentation of this file.

#ifndef MULTITHREADSIMENGINE_H_
#define MULTITHREADSIMENGINE_H_

#include "ThreadPool.h"
#include "SimObject.h"
#include "MultiThreadSpikeScheduler.h"
#include "SingleThreadSimEngine.h"
#include "MultiThreadAnalogMsgDispatcher.h"

#include <boost/thread/barrier.hpp>

class SimEngineAdvanceJob : public ThreadPoolJob
{
public :


    SimEngineAdvanceJob(SingleThreadSimEngine *eng, int numSteps);


    void setNumSteps(int nSteps);

    virtual void start();


protected :
    SingleThreadSimEngine *engine;
    int nSteps;
};

class SimEngineResetJob : public ThreadPoolJob
{
public:

    SimEngineResetJob(SingleThreadSimEngine *eng);

    virtual void start();

protected :
    SingleThreadSimEngine *eng;
};

class SimEngineInitializeJob : public ThreadPoolJob
{
public:

    SimEngineInitializeJob(SingleThreadSimEngine *eng);

    virtual void start();

protected :
    SingleThreadSimEngine *eng;
};


class CycleAdvanceJob : public ThreadPoolJob
{
public:
    CycleAdvanceJob(vector<AnalogDelayObject *> *analogDelayObjects)
            : analog_delay_objects(analogDelayObjects) {};




    virtual void start();

protected:
    vector<AnalogDelayObject *> *analog_delay_objects;
};

class SimNetwork;


class MultiThreadSimEngine : public SimEngine
{

public:


    MultiThreadSimEngine(int ID,
                         int numThreads,
                         ThreadPool &thrPool,
                         SpikeScheduler &scheduler,
                         AnalogMessageDispatcherVector &analogMsgDispatchers,
                         SimNetwork &net);



    virtual ~MultiThreadSimEngine();

    virtual void advance(int nSteps = 1);

    virtual void reset();

    virtual void initialize();

    virtual void addObject( SimObjectFactory const& objFactory, SimObject::ID &id )
    {
        engines[id.eng]->addObject( objFactory, id );
    };

    void addForAdvanceCycle( AnalogDelayObject *o, SimObject::ID &id)
    {
        o->setAddedForAdvanceCycle();
        analogDelayObjects[id.eng].push_back(o);
    }

    virtual void mount( const SimObjectFactory &objFactory, const SimObject::ID &mountpoint, SimObject::ID &gid );
    virtual void insert( const SimObjectFactory &objFactory, const SimObject::ID &mountpoint, SimObject::ID &gid );

    virtual SimObject *getObject(const SimObject::ID & id)
    {
        return engines[id.eng]->getObject(id);
    };

    SimObjectPool* getPool(engineid_t e)
    {
        return engines[e]->getPool();
    }

    void advanceSeveralStepsWithinACycle(int steps);

    void finalizeCycle();

    void advanceOneFullCycle();

    SingleThreadSimEngine & getSTEngine(engineid_t eng);

    virtual void seed( vector<uint32> const& noiseSeed );
    virtual void seed( uint32 noiseSeed );
    
    virtual void noiseRandEngineOutput( vector<uint32> & r );
    
protected:

    inline void two_way_link( const SimObject::ID &id1, const SimObject::ID &id2 );
    inline void one_way_link( const SimObject::ID &id1, const SimObject::ID &id2 );

    int _numThreads;

    ThreadPool &thr_pool;

    vector<SimEngineAdvanceJob> advance_jobs;

    vector<SimEngineResetJob> reset_jobs;

    vector<SimEngineInitializeJob> initialize_jobs;

    vector<SingleThreadSimEngine*> engines;

    boost::barrier *thr_barrier;

    vector< vector<AnalogDelayObject *> > analogDelayObjects;

    vector< CycleAdvanceJob > mtCycleAdvanceJobs;

    int currentStepWithinCycle;

} ;

#endif /*MULTITHREADSIMENGINE_H_*/

---