wxmsgbase.h

Go to the documentation of this file.

#ifndef wxmsgbase_h
#define wxmsgbase_h
 
// WarpX includes
#include "wxdatatypes.h"
#include "wxexcept.h"
#include "wxmsgtmpl.h"
#include "wxtypelist.h"
 
// std includes
#include <vector>
 
class WxMsgBase
{
public:
    virtual ~WxMsgBase()
    {
    }
 
    virtual int rank() const = 0;
 
    virtual unsigned numProcs() const = 0;
 
    WxMsgBase* parent() const
    {
        return _parent;
    }
 
    virtual WxMsgBase* createSubComm(const std::vector<int>& ranks) = 0;
 
    virtual WxMsgBase* splitComm(int color, int order) = 0;
 
    virtual void barrier() const = 0;
 
    template<typename T>
    void send(const std::vector<T>& array, unsigned recvRank, int tag = -1) const
    {
        this->_getMsg<T>()->send(
            array.size(), &(array[0]), recvRank, (tag == -1) ? _sendTag : tag);
    }
 
    template<typename T>
    void send(unsigned num, const T* array, unsigned recvRank, int tag = -1) const
    {
        this->_getMsg<T>()->send(num, array, recvRank, (tag == -1) ? _sendTag : tag);
    }
 
    template<typename T>
    WxMsgStatus
    startSend(const std::vector<T>& vec, unsigned recvRank, int tag = -1) const
    {
        return this->_getMsg<T>()->startSend(
            vec.size(), &(vec[0]), recvRank, (tag == -1) ? _sendTag : tag);
    }
 
    template<typename T>
    WxMsgStatus
    startSend(unsigned num, const T* arr, unsigned recvRank, int tag = -1) const
    {
        return this->_getMsg<T>()->startSend(
            num, arr, recvRank, (tag == -1) ? _recvTag : tag);
    }
 
    virtual void finishSend(WxMsgStatus ms) const = 0;
 
    template<typename T>
    void recv(int num, std::vector<T>& array, unsigned sendRank, int tag = -1) const
    {
        array.resize(num);
        this->_getMsg<T>()->recv(
            num, &(array[0]), sendRank, (tag == -1) ? _recvTag : tag);
    }
 
    template<typename T>
    void recv(unsigned num, T* array, unsigned sendRank, int tag = -1) const
    {
        this->_getMsg<T>()->recv(num, array, sendRank, (tag == -1) ? _recvTag : tag);
    }
 
    template<typename T>
    WxMsgStatus startRecv(unsigned num, unsigned sendRank, int tag = -1) const
    {
        return this->_getMsg<T>()->startRecv(num, sendRank, (tag == -1) ? _recvTag : tag);
    }
 
    template<typename T>
    WxMsgStatus startRecv(unsigned num, T* arr, unsigned sendRank, int tag = -1) const
    {
        return this->_getMsg<T>()->startRecv(
            num, arr, sendRank, (tag == -1) ? _recvTag : tag);
    }
 
    template<typename T>
    WxMsgStatus startRecv(std::vector<T>& vec, unsigned sendRank, int tag = -1) const
    {
        return startRecv(vec.size(), vec.data(), sendRank, tag);
    }
 
    virtual void* finishRecv(WxMsgStatus ms) const = 0;
 
    virtual bool checkRecv(WxMsgStatus ms) const = 0;
 
    template<typename T>
    void allReduce(unsigned num, T* sendBuff, T* recvBuff, MPI_Op op) const
    {
        this->_getMsg<T>()->allReduce(num, sendBuff, recvBuff, op);
    }
 
    template<typename T>
    std::vector<T> allReduce(std::vector<T> sendBuff, MPI_Op op) const
    {
        std::vector<T> recvBuff(sendBuff.size());
        this->_getMsg<T>()->allReduce(
            sendBuff.size(), &(sendBuff[0]), &(recvBuff[0]), op);
        return recvBuff;
    }
 
    template<typename T>
    void broadcast(unsigned num, T* buffer, int root) const
    {
        this->_getMsg<T>()->broadcast(num, buffer, root);
    }
 
protected:
    WxMsgBase(int sendTag = 0, int recvTag = 0, WxMsgBase* parent = 0)
        : _sendTag(sendTag), _recvTag(recvTag), _parent(parent)
    {
    }
 
    template<typename T> void addMsg(WxMsgTmpl<T>* b)
    {
        wxTypeMapExtract<T>(_msgTypeMap)._msg = b;
    }
 
private:
    // To prevent use
    WxMsgBase(const WxMsgBase&);
    WxMsgBase& operator=(const WxMsgBase&);
 
    int _sendTag, _recvTag;
    WxMsgBase* _parent;
 
    template<typename T> WxMsgTmpl<T>* _getMsg()
    {
        WxMsgTmpl<T>* r = wxTypeMapExtract<T>(_msgTypeMap)._msg;
        if (r)
            return r;
        WxExcept wxe;
        wxe << "Message type not set properly";
        throw wxe;
    }
 
    template<typename T> const WxMsgTmpl<T>* _getMsg() const
    {
        WxMsgTmpl<T>* r = wxTypeMapExtract<T>(_msgTypeMap)._msg;
        if (r)
            return r;
        WxExcept wxe;
        wxe << "Message type not set properly";
        throw wxe;
    }
 
public:
    //  xlC doesn't like internal private structs
 
    // Container class for all message-ers
    template<typename T> struct WxMsgContainer
    {
        WxMsgContainer() : _msg(0)
        {
        }
        virtual ~WxMsgContainer()
        {
            delete _msg;
        }
        // this points to a derived class of WxMsgTmpl<T>
        WxMsgTmpl<T>* _msg;
    };
 
    // Objects of type WxMsgTypeMap_t inherit from all WxMsgTmpl<T>
    // where T belongs to the WxMsgTypelist_t. Thus it acts like a
    // container for all message-er objects in the system.
    typedef WxTypeMap<WxDataTypes_t, WxMsgContainer> WxMsgTypeMap_t;
 
    WxMsgTypeMap_t _msgTypeMap; // container of communicators
};
 
#endif //  wxmsgbase_h