msgMpiPacked.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_MPI_PACKED_H
#define MSG_MPI_PACKED_H
 
using namespace std;
 
#include "msgCommon.h"
 
namespace openm
{
    class MpiPacked
    {
    public:
        template<typename TVal>
        static void pack(TVal i_value, int i_packedSize, void * io_packedData, int & io_packPos)
        {
            int mpiRet = MPI_Pack(&i_value, 1, toMpiType(typeid(TVal)), io_packedData, i_packedSize, &io_packPos, MPI_COMM_WORLD);
            if (mpiRet != MPI_SUCCESS) throw MpiException(mpiRet);
        }
 
        template<typename TVal>
        static TVal unpack(int i_packedSize, void * i_packedData, int & io_packPos)
        {
            TVal val;
            int mpiRet = MPI_Unpack(i_packedData, i_packedSize, &io_packPos, &val, 1, toMpiType(typeid(TVal)), MPI_COMM_WORLD);
            if (mpiRet != MPI_SUCCESS) throw MpiException(mpiRet);
 
            return val;
        }
 
        static void pack(const string & i_value, int i_packedSize, void * io_packedData, int & io_packPos);
 
        static string unpackStr(int i_packedSize, void * i_packedData, int & io_packPos);
 
        static unique_ptr<uint8_t[]> packArray(const type_info & i_type, size_t i_size, void * i_valueArr);
 
        static unique_ptr<uint8_t[]> packArray(size_t i_size, const string * i_valueArr);
 
        static void unpackArray(int i_packedSize, void * i_packedData, size_t i_size, string * io_valueArr);
 
        static int packedSize(const type_info & i_type, size_t i_size);
 
        static int packedSize(size_t i_size, const string * i_valueArr);
 
        static int packedSize(const type_info & i_type);
 
        static int packedSize(const string & i_value);
 
        static MPI_Datatype toMpiType(const type_info & i_type);
    };
 
    template<typename TRow> struct RowMpiPackedAdapter
    {
    public:
        static void pack(const IRowBaseUptr & i_row, int i_packedSize, void * io_packedData, int & io_packPos);
 
        static void unpackTo(const IRowBaseUptr & io_row, int i_packedSize, void * i_packedData, int & io_packPos);
 
        static int packedSize(const IRowBaseUptr & i_row);
    };
 
    template <MsgTag rowMsgTag, typename TRow> struct MetaMpiPackedAdapter : public IPackedAdapter
    {
    public:
        MsgTag tag(void) const noexcept override { return rowMsgTag; }
 
        const vector<uint8_t> pack(const IRowBaseVec & i_rowVec) const override
        {
            lock_guard<recursive_mutex> lck(msgMutex);
 
            int packSize = packedSize(i_rowVec);
            vector<uint8_t> packedData(packSize);
 
            int packPos = 0;
            int rowCount = (int)i_rowVec.size();
            MpiPacked::pack<int>(rowCount, packSize, packedData.data(), packPos);
 
            for (IRowBaseVec::const_iterator rowIt = i_rowVec.begin(); rowIt != i_rowVec.end(); rowIt++) {
                RowMpiPackedAdapter<TRow>::pack(*rowIt, packSize, packedData.data(), packPos);
            }
            return packedData;
        }
 
        void unpackTo(int i_packSize, void * i_packedData, IRowBaseVec & io_rowVec) const override
        {
            lock_guard<recursive_mutex> lck(msgMutex);
 
            int packPos = 0;
            int rowCount = MpiPacked::unpack<int>(i_packSize, i_packedData, packPos);
 
            for (int nRow = 0; nRow < rowCount; nRow++) {
                IRowBaseUptr row(new TRow());
                RowMpiPackedAdapter<TRow>::unpackTo(row, i_packSize, i_packedData, packPos);
                io_rowVec.push_back(std::move(row));
            }
        }
 
    private:
        int packedSize(const IRowBaseVec & i_rowVec) const
        {
            int packSize = MpiPacked::packedSize(typeid(int));
 
            for (IRowBaseVec::const_iterator rowIt = i_rowVec.begin(); rowIt != i_rowVec.end(); rowIt++) {
                packSize += RowMpiPackedAdapter<TRow>::packedSize(*rowIt);
            }
            return packSize;
        }
    };
}
 
#endif  // MSG_MPI_PACKED_H