MPI_MessageData.h

#ifndef MPI_MessageData_H
#define MPI_MessageData_H
 
//inherited class object
#include "MPI_Object.h"
 
//MPI types header
#include "MPI_Type.h"
 
class MPI_MessageData  : public MPI_Object {
   
    //attributes
private :
    tMPIRequest mRequest;
    tMPIStatus mStatus;
    tMPIInteger mIsAvaliable;
    tMPIInteger mIsFinished;
    tBoolean mIsUsed;
protected:
    // CONSTRUCTORS
    
    MPI_MessageData() {
        clear();   
    }
  
 
    // DESTRUCTORS 
    virtual ~MPI_MessageData(void) {    
   
    }
 
public: 
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=MPI_Object::getContentsMemorySize();
        return mem;
    }
 
    inline static CORE_UniquePointer<MPI_MessageData> New() {
        CORE_UniquePointer<MPI_MessageData> p(new MPI_MessagData(),
                                              MPI_MessageData::Delete());
        return p;
    };
    
    inline void clear() {
        mIsAvaliable=0;
        mIsFinished=0;
        mIsUsed=false;
        
    }
    inline void update(const MPI_Environment& env,
                  const tMPICoreId& sourceCore,
                  const tMPITag& tag) {
        MPI_Iprobe(sourceCore,tag,env.getWorld(),&mIsAvaliable,&mStatus);
    }
    inline void update(const MPI_Environment& env,
                       const tMPITag& tag) {
        MPI_Iprobe(MPI_ANY_SOURCE,tag,env.getWorld(),&mIsAvaliable,&mStatus);
    }
    inline void update(const MPI_Environment& env) {
       
        MPI_Iprobe(MPI_ANY_SOURCE,MPI_ANY_TAG,env.getWorld(),&mIsAvaliable,&mStatus);
    }
    
    inline tMPIRequest& request()  { return mRequest; }
  
    inline tBoolean isAvaliable() const {
      
        return (mIsAvaliable==1);
    }
 
    inline tMPICoreId getSourceCore() const {
        return (mIsAvaliable==1)?mStatus.MPI_SOURCE:-1;
    }
    inline tMPICoreId getTag() const {
        return (mIsAvaliable==1)?mStatus.MPI_TAG:-1;
    }
    template<typename T>
    inline tBoolean getCount(tMPICount& nElements) {
        return (MPI_Get_count(&mStatus,MPI_Type::GetPrimaryType<T>(),&nElements)==MPI_SUCCESS);
    }
 
    inline tBoolean isFinished()  {
        MPI_Test(&mRequest,&mIsFinished,&mStatus);
        return (mIsFinished==1);
    }
    inline const tBoolean& isUsed()  {
        return mIsUsed;
    }
    inline void setIsUsed(const tBoolean& b) {
        mIsUsed=b;
    }
 
    inline tBoolean wait() {
        return (MPI_Wait(&mRequest,&mStatus)==MPI_SUCCESS);
    }
    inline static void WaitAll(std::valarray<MPI_MessageData>& messages) {
        tBoolean allAreFinished=true;
        tMPIInteger isFinished;
        do {
            allAreFinished=true;
            for (auto& message:messages) {
                MPI_Test(&message.request(),&isFinished,MPI_STATUS_IGNORE);
                allAreFinished=allAreFinished && (isFinished==1);
            }
        } while (!allAreFinished);
        
    }
};
 
 
#endif