MPI_Type.h

#ifndef MPI_Type_H
#define MPI_Type_H
 
//mpi object
#include "MPI_Object.h"
 
 
//MPI data type
#define tMPIType MPI_Datatype
 
//MPI octet type
#define tMPIByte MPI_Aint
 
//MPI count type of a certain type
#define tMPICount int
 
//MPI flag type as a flag type
#define tMPITag int
 
//MPI core id  type
#define tMPICoreId int
 
//MPI integer
#define tMPIInteger int
#define tMPIIndex int
 
//MPI boolean
#define tMPIBoolean int
 
//index of nullcore
#define NULL_CORE  MPI_PROC_NULL
 
//MPI error type
#define tMPIError int
#define tMPIErrorMode MPI_Errhandler
 
//MPI communicator type
#define tMPIComm MPI_Comm
 
//view type
#define tMPIView MPI_Datatype
 
//MPI status of message
#define tMPIStatus MPI_Status
#define tMPIRequest MPI_Request
 
//MPI arithmetic operation
#define tMPIOperation MPI_Op
 
//IO Mode
#define tMPIIOMode int
 
//IO file
#define tMPIIOFile MPI_File
 
//IO file position
#define tMPIIOIndex MPI_Offset
 
class MPI_Type : public MPI_Object {
  
  
    // ATTRIBUTES
  
public:
  
 
    
private:
    tMPIType mType;
    tBoolean mIsRegistered;
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    MPI_Type(void) {
        mIsRegistered=false;
    }
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~MPI_Type(void) {
        unregisterType();
      
    }
 
public:
    //memory management
    //=================
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=MPI_Object::getContentsMemorySize();
        return mem;
    }
  
private:
    // SET methods
    
    inline void registerType() {
        if (mIsRegistered) unregisterType();
        MPI_Type::Register(mType);
        mIsRegistered=true;
    }
    inline void unregisterType() {
        if (mIsRegistered) MPI_Type::Unregister(mType);
        mIsRegistered=false;
    }
public:
  
    // GET methods 
 
    template<typename T>
    inline  tBoolean createContiguousType(const tMPICount& N) {
        unregisterType();
        tBoolean ret=(CreateContiguousType<T>(N,mType)==MPI_SUCCESS);
        registerType();
        return ret;
    }
    template<typename T>
    inline  tBoolean createConstantStepType(const tMPICount& N,
                                            const tMPICount& elementSize,
                                            const tMPICount& step) {
        unregisterType();
        tBoolean ret=(CreateConstantStepType<T>(N,elementSize,step,mType)==MPI_SUCCESS);
        registerType();
        return ret;
    }
    inline tBoolean  createConstantOctetStepType(const tMPICount& nElements,
                                                 const tMPICount& elementsNumber,
                                                 const tMPIByte& stepInOctets,
                                                 const tMPIType& oldType) {
        unregisterType();
        tBoolean ret=(CreateConstantOctetStepType(nElements,elementsNumber,stepInOctets,oldType,mType)==MPI_SUCCESS);
        registerType();
        return ret;
    }
    
    
    template<typename T>
    inline  tBoolean createVariableStepType(const tMPICount& nElements,
                                            const std::valarray<tMPICount>& elementSizes,
                                            const std::valarray<tMPICount>& elementIndices) {
        unregisterType();
        tBoolean ret=(CreateVariableStepType<T>(nElements,elementSizes,elementIndices,mType)==MPI_SUCCESS);
        registerType();
        return ret;
    }
 
    inline  tBoolean createVariableOctetStepType(const tMPICount& nElements,
                                                 const std::valarray<tMPICount>& elementSizes,
                                                 const std::valarray<tMPIByte>& elementOctetIndices,
                                                 const tMPIType& oldType) {
        unregisterType();
        tBoolean ret=(CreateVariableOctetStepType(nElements,elementSizes,elementOctetIndices,oldType,mType)==MPI_SUCCESS);
        registerType();
        return ret;
    }
    
    
    inline  tBoolean createStructType(const tMPICount& nElements,
                                      const std::valarray<tMPICount>& elementSizes,
                                      const std::valarray<tMPIByte>& elementOctetIndices,
                                      const std::valarray<tMPIType>& elementTypes) {
        unregisterType();
        tBoolean ret=(CreateStructType(nElements,elementSizes,elementOctetIndices,elementTypes,mType)==MPI_SUCCESS);
        registerType();
        return ret;
        
    }
    
  
 
public:
 
    inline const tMPIType& getType() const {
        return mType;
    }
 
    
    
    //primary type manupulation
    //==========================
 
public:
    template<class T>
    inline static tMPIType GetPrimaryType() {
        return MPI_Type::GetPrimaryType(functions_type::getTypeName<T>());
    }
 
    inline static tMPIType GetPrimaryType(const tString& typeName) {
        tMPIType  mpiType=0;
        
        switch(typeName[0]) {
        case 'b'://boolean
            mpiType=MPI_LOGICAL;
            break;
        case 'c'://char
            mpiType=MPI_CHAR;
            break;
        case 's'://short
            mpiType=MPI_SHORT;
            break;
        case 'i'://int
            mpiType=MPI_INT;
            break;
        case 'f'://float
            mpiType=MPI_FLOAT;
            break;
        case 'd'://double
            mpiType=MPI_DOUBLE;
            break;
        case 'l'://long
            switch(typeName[5]) {
            case 'i'://int
                mpiType=MPI_LONG;
                break;
            case 'l'://long
                mpiType=MPI_LONG_LONG;
                break;
            case 'd'://double
                mpiType=MPI_LONG_DOUBLE;
                break;
            }
            break;
        case 'u'://unsigned
            switch(typeName[9]) {
            case 'c'://char
                mpiType=MPI_UNSIGNED_CHAR;
                break;
            case 's'://short
                mpiType=MPI_UNSIGNED_SHORT;
                break;
            case 'i'://int
                mpiType=MPI_UNSIGNED;
                break;
            case 'l'://long
                mpiType=(typeName.length()>14)?MPI_UNSIGNED_LONG_LONG:MPI_UNSIGNED_LONG; 
                break;
            }
            break;
        default:
            throw CORE_Exception("mpi/MPI_Object",
                                 "GetVTKType("+typeName+")",
                                 "unknown type");
        }
       
        return mpiType;
    }
 
 
    //new type creator
    //==================
    template<typename T>
    inline static tMPIError CreateContiguousType(const tMPICount& N,tMPIType& newType) {
        return MPI_Type_contiguous(N,MPI_Type::GetPrimaryType<T>(),&newType);   
    }
    inline static tMPIError CreateContiguousType(const tMPICount& N,const tMPIType& oldType,tMPIType& newType) {
        return MPI_Type_contiguous(N,oldType,&newType);   
    }
 
  
    template<typename T>
    inline static tMPIError CreateConstantStepType(const tMPICount& nElements,
                                                   const tMPICount& elementSize,const tMPICount& step,
                                                   tMPIType& newType) {
        return MPI_Type_vector(nElements,elementSize,step,MPI_Type::GetPrimaryType<T>(),&newType);   
    }
    inline static tMPIError CreateConstantStepType(const tMPICount& nElements,
                                                   const tMPICount& elementSize,const tMPICount& step,
                                                   const tMPIType& oldType,
                                                   tMPIType& newType) {
        return MPI_Type_vector(nElements,elementSize,step,oldType,&newType);   
    }
    
    inline static tMPIError CreateConstantOctetStepType(const tMPICount& nElements,
                                                        const tMPICount& elementsNumber,
                                                        const tMPIByte& stepInOctets,
                                                        const tMPIType& oldType,
                                                        tMPIType& newType) {
        return MPI_Type_create_hvector(nElements,elementsNumber,stepInOctets,oldType,&newType);   
    }
    
    
    
    template<typename T>
    inline static tMPIError CreateVariableStepType(const tMPICount& nElements,
                                                   const std::valarray<tMPICount>& elementSizes,
                                                   const std::valarray<tMPICount>& elementIndices,
                                                   tMPIType& newType) {
        return MPI_Type_indexed(nElements,
                                &elementSizes[0],
                                &elementIndices[0],
                                MPI_Type::GetPrimaryType<T>(),
                                &newType);   
    }
    
    inline static tMPIError CreateVariableOctetStepType(const tMPICount& nElements,
                                                        const std::valarray<tMPICount>& elementSizes,
                                                        const std::valarray<tMPIByte>& elementOctetIndices,
                                                        const tMPIType& oldType,
                                                        tMPIType& newType) {
        return MPI_Type_create_hindexed(nElements,&elementSizes[0],&elementOctetIndices[0],oldType,&newType);   
    }
 
 
    inline static tMPIError CreateStructType(const tMPICount& nElements,
                                             const std::valarray<tMPICount>& elementSizes,
                                             const std::valarray<tMPIByte>& elementOctetIndices,
                                             const std::valarray<tMPIType>& elementTypes,
                                             tMPIType& newType) {
        return MPI_Type_create_struct(nElements,&elementSizes[0],&elementOctetIndices[0],&elementTypes[0],&newType);
        
    }
 
    template<typename T,tUCInt N>
    static void CreateFaceTypes(const tUCInt& dim,
                                const std::array<tInteger,N>& Ns,
                                std::array<MPI_Type,N>& faceTypes) {
 
        //value=d+dim*(i+j*Nx+k*Nx*Ny)
        
        //size of real 
        int mpiSizeOfT;
        MPI_Type::GetSize<T>(mpiSizeOfT);
        
        //create the type face 
        switch(Ns.size()) {
        case 1://DIM=1
            faceTypes[0].template createContiguousType<T>(dim);
            break;
        case 2://DIM=2
            //face normal to y : tILine
            faceTypes[1].template createContiguousType<T>(dim*Ns[0]);
            //face normal to x : tJLine
            faceTypes[0].template createConstantStepType<T>(Ns[1],dim,Ns[0]*dim);//Ny elements dy=Nx x dim
            break;
        case 3://DIM=3
            //index = dim * (i+Nx.j+Nx.Ny.k)
            //face normal to z
            faceTypes[2].template createContiguousType<T>(dim*Ns[0]*Ns[1]);//Nx.Ny.dim elements 
            
            //method 1:
            //tMPIType tKLine;//Kline
            //MPI_Type::CreateConstantStepType<T>(Ns[2],dim,Ns[0]*Ns[1]*dim,tKLine);//Nz elements  dz=Nx*Ny
            tMPIType tILine;//Iline
            MPI_Type::CreateContiguousType<tReal>(Ns[0]*dim,tILine);//1 element, size=Ns[0]x dim contiguous elements
            tMPIType tJLine;//JLine
            MPI_Type::CreateConstantStepType<tReal>(Ns[1],dim,Ns[0]*dim,tJLine);//Ns[1] elements of size dim x Ns[1] dy=Ns[0]*dim
            
            //face normal to y : i in [0,Nx[  k in [0,Nz[ index=dim*i+dim*Nx.Ny.k     (+ dim * j * Nx)
            //faceTypes[1].template createConstantOctetStepType(Ns[0],1,mpiSizeOfT,tKLine);//Nx x  KLine(), dx=1
            //Nz x  ILine, dz=(Nx).(Ny).dim.sizeof(T) size=Ns[2]*dim*Ns[0]
            faceTypes[1].createConstantOctetStepType(Ns[2],1,dim*Ns[0]*Ns[1]*mpiSizeOfT,tILine);
            //face normal to x : j in [0,Ny[  k in [0,Nz[ index=dim*Nx*j  + dim*Nx.Ny.k     (dim*i)
            //Nz x JLine,  dz=(Nx).(Ny)*dim.sizeof(T) size=Ns[2]*dim*Ns[1]
            faceTypes[0].createConstantOctetStepType(Ns[2],1,dim*Ns[0]*Ns[1]*mpiSizeOfT,tJLine);
            
           
            break;
        }
    }
 
 
    //type modification
    //================
   
    inline static tMPIError Resize(const tMPIType dataType,
                                   const tMPIByte& lb,
                                   const tMPIByte& extent,
                                   tMPIType& newDataType) {
        return MPI_Type_create_resized(dataType,lb,extent,&newDataType);
    }
 
 
    //committed new type
    //===================
    
    inline static tMPIError Register(tMPIType& type) {
        return MPI_Type_commit(&type);
    }
    inline static tMPIError Unregister(tMPIType& type) {
        return MPI_Type_free(&type);
    }
 
 
    //type analysis
    //=============
     
   
    template<typename T>
    inline static tMPIError GetSize(int& mpiSize) {
        return MPI_Type_size(MPI_Type::GetPrimaryType<T>(),&mpiSize);
    }
    inline static tMPIError GetSize(const tMPIType& mpiType,int& mpiSize) {
        return MPI_Type_size(mpiType,&mpiSize);
    }
    inline static tMPIError  GetExtent(const tMPIType& mpiType,tMPIByte& start,tMPIByte& mpiSize) {
        return MPI_Type_get_extent(mpiType,&start,&mpiSize);
    }
  
    template<typename T>
    inline static tMPIError GetExtent(tMPIByte& start,tMPIByte& mpiSize) {
        return MPI_Type_get_extent(GetPrimaryType<T>(),&start,&mpiSize);
    }
 
    
};
 
 
 
#endif