MultiThreadNetwork.h

Go to the documentation of this file.

#ifndef MULTITHREADNETWORK_H_
#define MULTITHREADNETWORK_H_

#include <string>
using std::string;

#include <boost/format.hpp>

//PropagatedSpikeBuffer
//TargetDelayMap

#include "SimObject.h"
#include "SimNetwork.h"

#include "PropagatedSpikeBuffer.h"
#include "MultiThreadSpikeScheduler.h"
#include "MultiThreadSimEngine.h"
#include "AnalogDelayObjectMap.h"
#include "STAnalogMessageCreator.h"
#include "MTAnalogMessageCreator.h"




class MultiThreadNetwork : public SimNetwork {

    public:

        MultiThreadNetwork(int nThreads, SimParameter sp = SimParameter::Default );

        MultiThreadNetwork(int nThreads, MPI::Intracomm &comm, SimParameter sp = SimParameter::Default );

        /* \param minSynDelay the minimum delay specified in simulation timesteps of the synapses in the network.
        * 
        * \param maxSynDelay the maximum delay specified in simulation timesteps of the synapses in the network.
        * 
        * \param DT Time interval of one simulation step.
        */

        virtual ~MultiThreadNetwork();

        //



        // virtual void addObject( SimObject *obj, const engineid_t eng, SimObject::ID &id);


        virtual void _addObject_( const SimObjectFactory &objFactory, const SimEngine::ID &loc, SimObject::ID &gid );

        virtual void _addObject_( const SimObjectFactory &objFactory, SimObject::ID &gid );





        virtual void _addSpikeMessage_(const SimObject::ID &sender, const port_t out, const SimObject::ID &receiver, const port_t in, const Time &delay);

        virtual void _addAnalogMessage_(const SimObject::ID &sender, int sender_port, const SimObject::ID &receiver, int recv_port, const Time &delay);

        virtual void _addAnalogMessage_(const SimObject::ID &sender, int sender_port, const SimObject::ID &receiver, string destfield, const Time &delay);

        virtual void _addAnalogMessage_(const SimObject::ID &sender, string srcfield, const SimObject::ID &receiver, int recv_port, const Time &delay);

        virtual void _addAnalogMessage_(const SimObject::ID &sender, string srcfield, const SimObject::ID &receiver, string destfield, const Time &delay);


        //


        virtual gl_engineid_t maxLocalEngineID(void) const;


    protected:

        friend class DistributedSingleThreadNetwork;
        friend class DistributedMultiThreadNetwork;


        virtual void _reset_();


        virtual void _advance_( int nSteps = 1 );

        virtual void _initialize_();

        static void addLocalSpikeMessage(
            MTSpikeRoutingTables *arg_tables, SimEngine *arg_simEngine, const  SimParameter &SP,
            const SimObject::ID &sender, spike_port_id_t sender_port, const SimObject::ID &receiver, const port_t in_port, step_t delay
        );

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

        virtual void _insert_( const SimObjectFactory &objFactory, const SimObject::ID &container, SimObject::ID &gid );

        /* The type of connection (spike or analog) is determined (guessed) automatically.
         * If delay < 0 then the value returned by the destination objects getManagedDelay() method is used.
         * If a positive value is specified this value overwrites the dstobj.getManagedDelay() value.
         * */
        virtual void _connect_( SimObject::ID const& src, port_t out, const SimObject::ID &dst, port_t in, int delay );


        virtual SimObject * _getObject_(const SimObject::ID &id);


        template<typename srcType, typename destType>
        int addGenericAnalogMessage(const SimObject::ID &sender,
                                    srcType senderPortOrField,
                                    const SimObject::ID &receiver,
                                    destType recvPortOrField, delay_t delay) {
            if (sender.eng == receiver.eng) {
                return stAnalogMsgCreators[sender.eng]->addAnalogMessage(sender,
                        senderPortOrField,
                        receiver,
                        recvPortOrField,
                        delay);
            } else {
                if(  delay < simParam.minDelay.in_steps( simParam.dt ) || delay > simParam.maxDelay.in_steps( simParam.dt ) ) {
                    throw(
                        PCSIM::ConstructionException(
                            "MultiThreadNetwork::addGenericAnalogMessage",
                            str( boost::format("Specified delay (%1% ms) out of range (min=%2% ms, max=%3% ms).") %
                                 (delay * simParam.dt.in_ms()) % simParam.minDelay.in_ms() % simParam.maxDelay.in_ms() )
                        )
                    );
                }
                return mtAnalogMsgCreator->addAnalogMessage(sender,
                                                            senderPortOrField,
                                                            receiver,
                                                            recvPortOrField,
                                                            delay);
            }

        }

        int nThreads;

        MTSpikeRoutingTables *tables;

        ThreadPool thrPool;

        vector<PropagatedSpikeBuffer*> STBuffers;

        MultiThreadSpikeScheduler *spikeScheduler;


        MultiThreadSimEngine *simEngine;

        vector<MultiThreadAnalogMsgDispatcher*> analogMsgDispatchers;

        vector< STAnalogMessageCreator *> stAnalogMsgCreators;

        MTAnalogMessageCreator *mtAnalogMsgCreator;

        AnalogDelayObjectMap *analogDelayObjectsMap;

        virtual void seed_noise_rng( uint32 noise_seed );

    private:
        void init();
        DistributionStrategy::LocalRoundRobin localRoundRobin;
};

/*
inline local_objectid_t MultiThreadNetwork::addObject( SimObject *o, nodeid_t nid, engineid_t eid )
{
    SimObject::ID id(nid,eid);
    addObject( o, id );
    return id.localid;
}
*/

#endif /*MULTITHREADNETWORK_H_*/

---