DistributedNetwork.h

Go to the documentation of this file.

#ifndef DISTRIBUTEDNETWORK_H_
#define DISTRIBUTEDNETWORK_H_


#include "globaldefinitions.h"
#include "SimNetwork.h"

#include <iostream>
using std::cerr;
using std::endl;

#include <mpi.h>

class DistributedSimEngine;


class DistributedNetwork : public SimNetwork
{
public:


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


    DistributedNetwork( int nThreads, MPI::Intracomm &mpiCommunicator, SimParameter sp = SimParameter::Default );


    virtual ~DistributedNetwork();


    inline MPI::Intracomm &getMpiComm() { return mpi_comm; };



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

    virtual void _addObject_( const SimObjectFactory &objFactory, SimObject::ID &id )
    {
        return _addObject_( objFactory, (*distributionStrategy)( this ), id );
    }

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

    //


    virtual gl_engineid_t getGlobalEngineID( const SimEngine::ID &eid ) const;

    virtual gl_engineid_t getGlobalEngineID( engineid_t eng ) const;

    virtual gl_engineid_t maxGlobalEngineID(void) const;

    virtual gl_engineid_t maxLocalEngineID(void) const;

    virtual const SimEngine::ID getLocation( gl_engineid_t gEID ) const;


public:

    struct ConnectInfo
    {
        ConnectInfo(void) :
                //                managed_delay(0),
                first_spike_output_port_id(INVALID_SPIKE_PORT_ID),
                nSpikeInputPorts(0),
                nSpikeOutputPorts(0),
                nAnalogInputPorts(0),
                nAnalogOutputPorts(0)
        { /*NOOP*/ };

        ConnectInfo(int sp, int si, int so, int ai, int ao) :
                //                managed_delay(md),
                first_spike_output_port_id(sp),
                nSpikeInputPorts(si),
                nSpikeOutputPorts(so),
                nAnalogInputPorts(ai),
                nAnalogOutputPorts(ao)
        { /*NOOP*/ };

        //        int managed_delay;
        int first_spike_output_port_id;
        int nSpikeInputPorts;
        int nSpikeOutputPorts;
        int nAnalogInputPorts;
        int nAnalogOutputPorts;

        bool operator!=(const ConnectInfo& other) const
        {
            return // ( this->managed_delay != other.managed_delay ) ||
                ( this->first_spike_output_port_id != other.first_spike_output_port_id ) ||
                ( this->nSpikeInputPorts != other.nSpikeInputPorts ) ||
                ( this->nSpikeOutputPorts != other.nSpikeOutputPorts ) ||
                ( this->nAnalogInputPorts != other.nAnalogInputPorts ) ||
                ( this->nAnalogOutputPorts != other.nAnalogOutputPorts ) ;
        };

        bool operator==(const ConnectInfo& other) const
        {
            return // ( this->managed_delay == other.managed_delay ) &&
                ( this->first_spike_output_port_id == other.first_spike_output_port_id ) &&
                ( this->nSpikeInputPorts == other.nSpikeInputPorts ) &&
                ( this->nSpikeOutputPorts == other.nSpikeOutputPorts ) &&
                ( this->nAnalogInputPorts == other.nAnalogInputPorts ) &&
                ( this->nAnalogOutputPorts == other.nAnalogOutputPorts ) ;
        };

    };

protected:

    friend class DistributedMultiThreadNetworkTest;

    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 );

    virtual void _addSpikeMessage_(const SimObject::ID &sender, const port_t out, const spike_port_id_t sender_port, const SimObject::ID &receiver, const port_t port, const step_t delay)
    {
        cerr << "THIS MUST NEVER HAPPEN!!!!" << endl;
    };

    /* 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 );

    // void locallyGetConnectInfo( const SimObject::ID &oid, ConnectInfo &ci );
    // void getConnectInfo( const SimObject::ID &sender, const SimObject::ID &receiver, ConnectInfo &senderInfo, ConnectInfo &receiverInfo );
    // void conditionallyExchangeConnectInfo( const ConnectInfo &senderInfo, const SimObject::ID &receiver, ConnectInfo &receiverInfo );

    // void getPortInfo( const SimObject::ID &sender,  SimObject::PortInfo &senderInfo  );
    spike_port_id_t getFirstSenderSpikePort( const SimObject::ID &oid );
    /*  spike_port_id_t getFirstSenderSpikePort( const SimObject::ID &sender, const port_t out, const SimObject::ID &receiver );
      spike_port_id_t locallyGetFirstSenderSpikePort( const SimObject::ID &sender, const port_t out  );
      void transFirstSenderPort( spike_port_id_t first_sender_port, nodeid_t rec_node );
      spike_port_id_t recvFirstSenderPort( const SimObject::ID &sender );

      double getManagedDelay( const SimObject::ID &sender, const SimObject::ID &receiver );
      double locallyGetManagedDelay( const SimObject::ID &sender );
      void transManagedDelay( const SimObject::ID &receiver, double d );
      double recvManagedDelay( const SimObject::ID &sender ); */

    // virtual local_objectid_t addObjectLocally( SimObject *o, engineid_t eng = 0 ) = 0;

    MPI::Intracomm &mpi_comm;

    DistributedSimEngine *distEngine;


    SimEngine *localSimEngine;

    vector< vector< gl_engineid_t > > glengineids;

    vector<bool> incomingConnections;
    vector<bool> outgoingConnections;


    void setupGlEngineIDs(unsigned int numLocalEngines = 1);

    gl_engineid_t _max_global_engine_id;

    vector< SimEngine::ID > location;


    local_objectid_t getGhostID( gl_engineid_t gEID, SimObjectFactory const& objFactory  );

    vector< vector< local_objectid_t > > objectCounter;

    vector< spike_port_id_t > spikePortCounter;
    // vector< vector< vector< SimObject::PortInfo > > > ghostPortInfo;
    vector< vector< vector< spike_port_id_t > > > ghostFirstPortInfo;


    virtual void seed_noise_rng( uint32 noise_seed );

        virtual uint32 getUniqueSeedOverMpi( uint32 seed );

private:
    void init();
    int _nThreads;
    DistributionStrategy::GlobalRoundRobin globalRoundRobin;

};


ostream& operator<<(ostream &s, const DistributedNetwork::ConnectInfo &ci);


#endif /*DISTRIBUTEDNETWORK_H_*/

---