msg.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 OM_MSG_H
#define OM_MSG_H
 
#include <string>
using namespace std;
 
#include "libopenm/omLog.h"
#include "libopenm/omModelRunState.h"
#include "libopenm/common/omHelper.h"
#include "libopenm/db/dbCommon.h"
 
namespace openm
{
    extern const char msgUnknownErrorMessage[];
 
    typedef OpenmException<4000, msgUnknownErrorMessage> MsgException;
 
    enum class MsgTag
    {
        unused = 0,
 
        initial,
 
        statusUpdate,
 
        microdataSize,
 
        microdata,
 
        langLst = 32,
 
        langWord,
 
        modelDic,
 
        typeDic,
 
        typeEnumLst,
 
        parameterDic,
 
        parameterDims,
 
        tableDic,
 
        tableDims,
 
        tableAcc,
 
        tableExpr,
 
        entityDic,
 
        entityAttr,
 
        runOption,
 
        codeValue,
 
        //inParam,
 
        outSubValueBase = 128
    };
 
    struct IPackedAdapter
    {
    public:
        virtual ~IPackedAdapter(void) noexcept { }
 
        static IPackedAdapter * create(MsgTag i_msgTag);
 
        virtual MsgTag tag(void) const noexcept = 0;
 
        virtual const vector<uint8_t> pack(const IRowBaseVec & i_rowVec) const = 0;
 
        virtual void unpackTo(int i_packSize, void * i_packedData, IRowBaseVec & io_rowVec) const = 0;
 
        static size_t packedSize(const type_info & i_type, size_t i_size);
 
        static unique_ptr<uint8_t[]> packArray(const type_info & i_type, size_t i_size, void * i_valueArr);
    };
 
    class IMsgExec
    {
    public:
        virtual ~IMsgExec(void) noexcept = 0;
 
        static IMsgExec * create(int argc, char **argv, IFinalState * i_final);
 
        static const int rootRank = 0;
 
        bool isRoot(void) const { return rank() == rootRank; }
 
        virtual int worldSize(void) const = 0;
 
        virtual int rank(void) const = 0;
 
        virtual int groupRank(void) const = 0;
 
        virtual void setCleanExit(bool i_isClean = false) = 0;
 
        virtual void createGroups(int i_groupSize, int i_groupCount) = 0;
 
        virtual void bcastValue(int i_groupOne, const type_info & i_type, void * io_value) = 0;
 
        void bcastInt(int i_groupOne, void * io_value) { bcastValue(i_groupOne, typeid(int), io_value); }
 
        virtual void bcastSend(int i_groupOne, const type_info & i_type, size_t i_size, void * io_valueArr) = 0;
 
        virtual void bcastReceive(int i_groupOne, const type_info & i_type, size_t i_size, void * io_valueArr) = 0;
 
 
        virtual void bcastSendPacked(int i_groupOne, IRowBaseVec & io_rowVec, const IPackedAdapter & i_adapter) = 0;
 
        virtual void bcastReceivePacked(int i_groupOne, IRowBaseVec & io_rowVec, const IPackedAdapter & i_adapter) = 0;
 
        virtual void startSend(int i_sendTo, MsgTag i_msgTag, const type_info & i_type, size_t i_size, void * i_valueArr) = 0;
 
        virtual void startSendPacked(int i_sendTo, const IRowBaseVec & i_rowVec, const IPackedAdapter & i_adapter) = 0;
 
        virtual bool tryReceive(int i_recvFrom, MsgTag i_msgTag, const type_info & i_type, size_t i_size, void * io_valueArr) const = 0;
 
        virtual bool tryReceive(int i_recvFrom, IRowBaseVec & io_resultRowVec, const IPackedAdapter & i_adapter) const = 0;
 
        virtual void waitSendAll(void) = 0;
    };
}
 
#endif  // OM_MSG_H