msgEmpty.h

Go to the documentation of this file.

 
// Copyright (c) 2013-2015 OpenM++
// This code is licensed under the MIT license (see LICENSE.txt for details)
 
#ifndef MSG_EMPTY_H
#define MSG_EMPTY_H
 
using namespace std;
 
#include "msgExecBase.h"
 
namespace openm
{
    struct EmptyPackedAdapter : public IPackedAdapter
    {
    public:
        EmptyPackedAdapter(MsgTag i_tag) : msgTag(i_tag) { }
 
        MsgTag tag(void) const noexcept override { return msgTag; }
 
        const vector<uint8_t> pack(const IRowBaseVec & /* i_rowVec */) const override
        { 
            lock_guard<recursive_mutex> lck(msgMutex);
            vector<uint8_t> packedData;
            return packedData;
        }
 
        void unpackTo(int /* i_packSize */, void * /* i_packedData */, IRowBaseVec & /* io_rowVec */) const override { }
 
    private:
        MsgTag msgTag;  // message tag
    };
 
    class MsgEmptyExec : public IMsgExec, public MsgExecBase
    {
    public:
        MsgEmptyExec(int & /* argc */, char ** & /* argv */, IFinalState * i_final) : MsgExecBase(i_final) { }
 
        ~MsgEmptyExec(void) noexcept { }
 
        int worldSize(void) const override { return MsgExecBase::worldSize(); }
 
        int rank(void) const override { return MsgExecBase::rank(); }
 
        int groupRank(void) const noexcept override { return MsgExecBase::groupRank(); }
 
        void setCleanExit(bool /*i_isClean*/) override { }
 
        void createGroups(int /*i_groupSize*/, int /*i_groupCount*/) override { }
 
        void bcastValue(
            int /*i_groupOne*/, const type_info & /*i_type*/, void * /*io_value*/
            ) override { }
 
        void bcastSend(
            int /*i_groupOne*/, const type_info & /*i_type*/, size_t /*i_size*/, void * /*io_valueArr*/
            ) override { }
 
        void bcastReceive(
            int /*i_groupOne*/, const type_info & /*i_type*/, size_t /*i_size*/, void * /*io_valueArr*/
            ) override { }
 
        void bcastSendPacked(
            int /*i_groupOne*/, IRowBaseVec & /*io_rowVec*/, const IPackedAdapter & /*i_adapter*/
            ) override { }
 
        void bcastReceivePacked(
            int /*i_groupOne*/, IRowBaseVec & /*io_rowVec*/, const IPackedAdapter & /*i_adapter*/
            ) override { }
 
        void startSend(int i_sendTo, MsgTag i_msgTag, const type_info & i_type, size_t i_size, void * i_valueArr) override
        { MsgExecBase::startSend(i_sendTo, i_msgTag, i_type, i_size, i_valueArr); }
 
        void startSendPacked(int i_sendTo, const IRowBaseVec & i_rowVec, const IPackedAdapter & i_adapter) override
        { MsgExecBase::startSendPacked(i_sendTo, i_rowVec, i_adapter); }
 
        bool tryReceive(int i_recvFrom, IRowBaseVec & io_resultRowVec, const IPackedAdapter & i_adapter) const override
        { return MsgExecBase::tryReceive(i_recvFrom, io_resultRowVec, i_adapter); }
 
        bool tryReceive(int i_recvFrom, MsgTag i_msgTag, const type_info & i_type, size_t i_size, void * io_valueArr) const override
        { return MsgExecBase::tryReceive(i_recvFrom, i_msgTag, i_type, i_size, io_valueArr); }
 
        void waitSendAll(void) override { MsgExecBase::waitSendAll(); }
 
    private:
        MsgEmptyExec(const MsgEmptyExec & i_exec) = delete;
        MsgEmptyExec & operator=(const MsgEmptyExec & i_exec) = delete;
    };
 
    class MsgEmptySendBase
    {
    public:
        MsgEmptySendBase(int i_selfRank, int i_sendTo, MsgTag i_msgTag) :
            msgTag((int)i_msgTag),
            selfRank(i_selfRank),
            sendToRank(i_sendTo)
        { }
 
        virtual ~MsgEmptySendBase(void) noexcept { }
 
    protected:
        int msgTag;         // MPI message tag
        int selfRank;       // source (ourself) MPI process rank
        int sendToRank;     // destination MPI process rank
 
    private:
        MsgEmptySendBase(const MsgEmptySendBase & i_send) = delete;
        MsgEmptySendBase & operator=(const MsgEmptySendBase & i_send) = delete;
    };
 
    class MsgEmptySendArray : public IMsgSendArray, public MsgEmptySendBase
    {
    public:
        MsgEmptySendArray(
            int i_selfRank, int i_sendTo, MsgTag i_msgTag, const type_info & i_type, size_t i_size, void * i_valueArr
            ) : 
            MsgEmptySendBase(i_selfRank, i_sendTo, i_msgTag),
            valueType(i_type),
            arrSize(i_size),
            valueArr(i_valueArr)
        { }
 
        ~MsgEmptySendArray(void) noexcept { }
 
        bool isCompleted(void) { return true; }
 
    private:
        const type_info & valueType;    // type of value in array
        size_t arrSize;                 // size of array
        void * valueArr;                // value array
 
    private:
        MsgEmptySendArray(const MsgEmptySendArray & i_send) = delete;
        MsgEmptySendArray & operator=(const MsgEmptySendArray & i_send) = delete;
    };
 
    class MsgEmptySendPacked : public IMsgSendPacked, public MsgEmptySendBase
    {
    public:
        MsgEmptySendPacked(
            int i_selfRank, int i_sendTo, const IRowBaseVec & i_rowVec, const IPackedAdapter & i_adapter
            ) : 
            MsgEmptySendBase(i_selfRank, i_sendTo, i_adapter.tag()),
            rowVec(i_rowVec),
            packAdp(i_adapter)
        { }
 
        ~MsgEmptySendPacked(void) noexcept { }
 
        bool isCompleted(void) { return true; }
 
    private:
        const IRowBaseVec & rowVec;     // vector of db rows
        const IPackedAdapter & packAdp; // adapter to pack db rows data
 
    private:
        MsgEmptySendPacked(const MsgEmptySendPacked & i_send) = delete;
        MsgEmptySendPacked & operator=(const MsgEmptySendPacked & i_send) = delete;
    };
 
    class MsgEmptyRecvArray : public IMsgRecvArray
    {
    public:
        MsgEmptyRecvArray(
            int i_selfRank, int i_recvFrom, MsgTag i_msgTag, const type_info & i_type, size_t i_size, void * io_valueArr
            ) :
            msgTag((int)i_msgTag),
            selfRank(i_selfRank),
            recvFromRank(i_recvFrom),
            valueType(i_type),
            resultSize(i_size),
            resultValueArr(io_valueArr)
        { }
 
        ~MsgEmptyRecvArray(void) noexcept { }
 
        bool tryReceive(void) { return true; }
 
    private:
        int msgTag;                     // message tag
        int selfRank;                   // destination (ourself) process rank
        int recvFromRank;               // source process rank
        const type_info & valueType;    // type of value in array
        size_t resultSize;              // expected size of array
        void * resultValueArr;          // received data
 
    private:
        MsgEmptyRecvArray(const MsgEmptyRecvArray & i_recv) = delete;
        MsgEmptyRecvArray & operator=(const MsgEmptyRecvArray & i_recv) = delete;
    };
 
    class MsgEmptyRecvPacked : public IMsgRecvPacked
    {
    public:
        MsgEmptyRecvPacked(
            int i_selfRank, int i_recvFrom, IRowBaseVec & io_resultRowVec, const IPackedAdapter & i_adapter
            ) :
            selfRank(i_selfRank),
            recvFromRank(i_recvFrom),
            resultRowVec(io_resultRowVec),
            packAdp(i_adapter)
        { }
 
        ~MsgEmptyRecvPacked(void) noexcept { }
 
        bool tryReceive(void) { return true; }
 
    private:
        int selfRank;                   // destination (ourself) process rank
        int recvFromRank;               // source process rank
        IRowBaseVec & resultRowVec;     // received data
        const IPackedAdapter & packAdp; // adapter to unpack received data
 
    private:
        MsgEmptyRecvPacked(const MsgEmptyRecvPacked & i_recv) = delete;
        MsgEmptyRecvPacked & operator=(const MsgEmptyRecvPacked & i_recv) = delete;
    };
}
 
#endif  // MSG_EMPTY_H