MPI_Environment.h

#ifndef MPI_Environment_H
#define MPI_Environment_H
 
//inherited class object
#include "MPI_Object.h"
 
//MPI types header
#include "MPI_Type.h"
 
class MPI_Environment  : public MPI_Object {
   
    //attributes
private :
 
    //name of the environment
    tMPIComm mWorld;
    //number of cores of the nevironments
    tMPICoreId mCoresNumber;
    //core id 
    tMPICoreId mCoreId;
 
    //root environment
    tBoolean mIsRootEnvironment;
   
protected:
    // CONSTRUCTORS
    
    MPI_Environment() {
      
    }
    
    MPI_Environment(int& argc,char * argv[],const tBoolean& isOpenMPEnabled) {
        if (isOpenMPEnabled) {
            int provided, required=MPI_THREAD_FUNNELED;
            MPI_Init_thread(&argc,&argv,required,&provided);
        } else {
            MPI_Init(&argc,&argv);
        }
        mWorld=MPI_COMM_WORLD;
        mIsRootEnvironment=false;
    }
 
    // DESTRUCTORS 
    virtual ~MPI_Environment(void) {
      
        if (mWorld==MPI_COMM_WORLD) {
            MPI_Finalize();
        } else if (mWorld!=MPI_COMM_NULL) {
            MPI_Comm_free(&mWorld);
            if (mIsRootEnvironment)   {
                MPI_Finalize();
            }
        }
        
    }
 
protected :
    virtual void initialize() {
        MPI_Comm_size(mWorld,&mCoresNumber);
        MPI_Comm_rank(mWorld,&mCoreId);
    }
 
public:
    
    inline static CORE_UniquePointer<MPI_Environment> New(int argc,char *argv[],const tBoolean& isOpenMPEnabled) {
        CORE_UniquePointer<MPI_Environment> p(new MPI_Environment(argc,argv,isOpenMPEnabled),
                                              MPI_Environment::Delete());
        p->initialize();
        return p;
    };
    inline static CORE_UniquePointer<MPI_Environment> New(int argc,char *argv[]) {
        return New(argc,argv,false);
    };
    
    
    //memory management
    //=================
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=MPI_Object::getContentsMemorySize();
        return mem;
    }
 
protected:
    inline void setIsRootEnvironment(const tBoolean& isRoot) {
        mIsRootEnvironment=isRoot;
    }
public:
    //accessor methods
    //----------------
 
    inline  const tMPIComm& getWorld() const {
        return mWorld;
    }
 
//protected:
    inline tMPIComm& getWorld() {
        return mWorld;
    }
public:
 
    inline const tMPICoreId&  getCoresNumber() const {
        return mCoresNumber;
    }
    inline static void GetCoresNumber(tMPICoreId& coresNumber)  {
        MPI_Comm_size(MPI_COMM_WORLD,&coresNumber);
    }
    inline static void GetCoresNumber(const MPI_Environment& env,tMPICoreId& coresNumber)  {
        MPI_Comm_size(env.getWorld(),&coresNumber);
    }
    
    inline const tMPICoreId& getCoreId() const {
        return mCoreId;
    }
 
 
public:
    
    inline static void GetCoreId(tMPICoreId& id)  {
        MPI_Comm_rank(MPI_COMM_WORLD,&id);
    }
    inline static void GetCoreId(const MPI_Environment& env,tMPICoreId& id) {
        MPI_Comm_rank(env.getWorld(),&id);
    }
 
    
    //time management methods
    //-----------------------
    inline static tReal GetTime() {
        return MPI_Wtime();
    }
 
    //process killer methods
    //-----------------------
   
    
    inline static tMPIError Abort(const MPI_Environment& env,const tMPIError& errCode) {
        return MPI_Abort(env.getWorld(),errCode);
    }
    inline static tMPIError Abort(const tMPIError& errCode) {
        return MPI_Abort(MPI_COMM_WORLD,errCode);
    }
 
    inline tMPIError abort(const tMPIError& errCode) const {
        return MPI_Abort(mWorld,errCode);
    }
 
    //syncronize methods
    //==================
    inline static tBoolean  Synchronize(const MPI_Environment& env) {
        //std::cout<<"begin MPI_WorldToWorldMessage::Synchronize(env) coreId="<<env.getCoreId()<<"\n";
        return (MPI_Barrier(env.getWorld())==MPI_SUCCESS);
        //std::cout<<"end MPI_WorldToWorldMessage::Synchronize(env) coreId="<<env.getCoreId()<<"\n";
    }
    inline static tBoolean  Synchronize() {
        //std::cout<<"begin MPI_WorldToWorldMessage::Synchronize()"<<"\n";
        return (MPI_Barrier(MPI_COMM_WORLD)==MPI_SUCCESS);
        //std::cout<<"end MPI_WorldToWorldMessage::Synchronize()"<<"\n";
    }
 
    inline tBoolean  synchronize() const {
        //std::cout<<"begin MPI_WorldToWorldMessage::Synchronize()"<<"\n";
        return (MPI_Barrier(getWorld())==MPI_SUCCESS);
        //std::cout<<"end MPI_WorldToWorldMessage::Synchronize()"<<"\n";
    }
    
    //Wait methods
    //============
    
    inline static tBoolean Wait(tMPIRequest& request,tMPIStatus& status) {
        return (MPI_Wait(&request,&status)==MPI_SUCCESS);
    }
    static inline tBoolean  Wait(tMPIRequest& request) {
        return (MPI_Wait(&request,MPI_STATUS_IGNORE)==MPI_SUCCESS);
    }
    
    inline static tBoolean WaitAll(const tMPICount& nRequests,tMPIRequest requests[],tMPIStatus statuses[]) {
        return (MPI_Waitall(nRequests,requests,statuses)==MPI_SUCCESS);
    }
 
    static inline tBoolean  WaitAll(std::valarray<tMPIRequest>& requests) {
        return (MPI_Waitall(requests.size(),
                            &requests[0],
                            MPI_STATUSES_IGNORE)==MPI_SUCCESS);
    }
    template<size_t D>
    static inline tBoolean  WaitAll(std::array<tMPIRequest,D>& requests) {
        return (MPI_Waitall(D,
                            requests.data(),
                            MPI_STATUSES_IGNORE)==MPI_SUCCESS);
    }
    static inline tBoolean  WaitAll(const tMPICount& nRequests,tMPIRequest* requests) {
        return (MPI_Waitall(nRequests,
                            requests,
                            MPI_STATUSES_IGNORE)==MPI_SUCCESS);
    }
    
    //test messages methods
    //======================
    
    static inline tBoolean  IsFinished(tMPIRequest& request,tMPIInteger& isFinished) {
        MPI_Test(&request,&isFinished,MPI_STATUS_IGNORE);
        return (isFinished==1);
    }
    static inline tBoolean  IsAllFinished(std::valarray<tMPIRequest>& requests,tMPIInteger& isFinished) {
        tBoolean isAllFinished=true;
        for(auto& req:requests) {
            MPI_Test(&req,&isFinished,MPI_STATUS_IGNORE);
            isAllFinished=isAllFinished && (isFinished==1);
        }
        return isAllFinished;
    }
    
    inline static  tBoolean IsFinished(tMPIRequest& request,tMPIStatus& status,tMPIInteger& isFinished) {
        MPI_Test(&request,&isFinished,&status);
        return (isFinished==1);
    }
    inline tBoolean isMessageAvaliable(tMPICoreId& source,
                                       tMPITag& tag,
                                       tMPIBoolean& isAvailable,
                                       tMPIStatus& status) const {
        return (IsMessageAvaliable(*this,source,tag,isAvailable,status));
    }
    
    static inline tBoolean IsMessageAvaliable(const MPI_Environment& env,
                                              tMPICoreId& source,
                                              tMPITag& tag,
                                              tMPIBoolean& isAvailable,
                                              tMPIStatus& status) {
        
        MPI_Iprobe(MPI_ANY_SOURCE,MPI_ANY_TAG,env.getWorld(),&isAvailable,&status);
        if (isAvailable==1) {
            source=status.MPI_SOURCE;
            tag=status.MPI_TAG;
            return true;
        }
        return false;
    }
    static inline tBoolean IsMessageAvaliable(const MPI_Environment& env,
                                              const tMPITag& tag,
                                              const tMPICoreId& source,
                                              tMPIBoolean& isAvailable) {
        return (MPI_Iprobe(source,tag,env.getWorld(),&isAvailable,MPI_STATUS_IGNORE)==MPI_SUCCESS);
    }
   
    static inline tBoolean IsTagMessageAvaliable(const MPI_Environment& env,
                                                 const tMPITag& tag,
                                                 tMPICoreId& source,
                                                 tMPIBoolean& isAvailable,
                                                 tMPIStatus& status) {
        MPI_Iprobe(MPI_ANY_SOURCE,tag,env.getWorld(),&isAvailable,&status);
        if (isAvailable==1) {
            source=status.MPI_SOURCE;
            return true;
        }
        return false;
    }
    
  
    
    template<typename T>
    inline static tBoolean GetCount(const tMPIStatus& status,tMPICount& nElements) {
        return (MPI_Get_count(&status,MPI_Type::GetPrimaryType<T>(),&nElements)==MPI_SUCCESS);
    }
    
    
    
};
 
 
#endif