DistributedIncomingAnalogMsgDispatcher.h

Go to the documentation of this file.

#ifndef DISTRIBUTEDINCOMINGANALOGMSGDISPATCHER_H_
#define DISTRIBUTEDINCOMINGANALOGMSGDISPATCHER_H_


#include <vector>
#include <string>
#include <utility>

#include "SimObject.h"
#include "DistIncomingAnalogSources2BufPosMap.h"
#include "MPIInputBuffer.h"
#include "AnalogDelayObject.h"

using std::vector;
using std::string;
using std::pair;
using std::make_pair;

class DistributedIncomingAnalogMsgDispatcher
{
public:

    DistributedIncomingAnalogMsgDispatcher(delay_t minimumDelay,  MPIInputBuffer *mpiInputBuffer, DistIncomingAnalogSources2BufPosMap *bufferPositionsOfIncomingSources);

    virtual ~DistributedIncomingAnalogMsgDispatcher();

    /*template<typename AnalogSrcType>
    void addDirectIncAnalogMessage(SimObject::ID &src, AnalogSrcType srcFieldOrPort, SimObject *dest, string destfield);

       template<typename AnalogSrcType>
    void addDirectIncAnalogMessage(SimObject::ID &src, AnalogSrcType srcFieldOrPort, SimObject *dest, analog_port_id_t dest_port);*/


    //void dispatchMPIIncomingAnalogMsgs(int step);

    void dispatchDelayerCycledIncomingAnalogMsgs();

    void initialize();

    void reset(double dt);

    template <typename AnalogSrcType>
    inline IncomingAnalogDelayObject*
    addDelayerCycledIncomingAnalogMessage(const SimObject::ID &src, AnalogSrcType srcFieldOrPort);

protected:

    int nNodes;

    delay_t minDelay;

    /*  typedef vector< vector< pair<SimObject*,analog_port_id_t> > > port_incoming_analog_msgs_type;
        port_incoming_analog_msgs_type port_analog_msgs;

        typedef vector< vector<double *> > field_incoming_analog_msgs_type;
        field_incoming_analog_msgs_type field_analog_msgs;

        vector< unsigned > port_msgs_buff_pos;
        vector< unsigned > field_msgs_buff_pos;

        vector< unsigned > *port_buf_pos_source_eng_ids;

        vector< unsigned > *field_buf_pos_source_eng_ids;
    */
    // Sources and destinations for the (mpi input buffer) -> (incoming delayers) transfer
    //  (cycled incoming analog msgs)
    vector< unsigned > cycled_inc_msgs_src_buff_pos;

    vector< engineid_t > *cycled_buf_pos_source_eng_ids;

    vector< IncomingAnalogDelayObject *> cycled_inc_msgs_delayer_destinations;

    /*  typedef hash_map< unsigned, unsigned > buff_pos2msglist_pos_type;

        buff_pos2msglist_pos_type *field_msgs_positions;

        buff_pos2msglist_pos_type *port_msgs_positions;    */

    // [simobject][port/field] -> buffer position or NULL
    DistIncomingAnalogSources2BufPosMap * bufPosOfIncomingSources;

    MPIInputBuffer *inputBuffer;

    double * mpiBufferPtr;

    bool initialized;
};

template <typename AnalogSrcType>
inline IncomingAnalogDelayObject*
DistributedIncomingAnalogMsgDispatcher::addDelayerCycledIncomingAnalogMessage(const SimObject::ID &src, const AnalogSrcType srcFieldOrPort)
{
    typename DistIncomingAnalogSources2BufPosMap::type<AnalogSrcType>::iterator iter = bufPosOfIncomingSources->find(src, srcFieldOrPort);
    if (iter == bufPosOfIncomingSources->end(srcFieldOrPort)) {
        /* there is no position for this source so we need to register one */
        unsigned buf_position = inputBuffer->getAnalogMsgCounter(src.eng)++;
        IncomingAnalogDelayObject *ado = new IncomingAnalogDelayObject(minDelay);
        bufPosOfIncomingSources->insert(src, srcFieldOrPort, buf_position, ado);
        cycled_inc_msgs_src_buff_pos.push_back(buf_position);
        cycled_buf_pos_source_eng_ids->push_back(src.eng);
        cycled_inc_msgs_delayer_destinations.push_back(ado);

        return ado;
    } else
        if (!iter->second.second) {
            /* there is a position but no incoming analog delay object */
            IncomingAnalogDelayObject *ado = new IncomingAnalogDelayObject(minDelay);
            iter->second.second = ado;
            cycled_inc_msgs_src_buff_pos.push_back(iter->second.first);
            cycled_buf_pos_source_eng_ids->push_back(src.eng);
            cycled_inc_msgs_delayer_destinations.push_back(ado);
            return ado;
        } else {
            return iter->second.second ;  // return the delayer object
        }
    return NULL;
}

#endif /*DISTRIBUTEDINCOMINGANALOGMSGDISPATCHER_H_*/

---