MPI_CoreToCoreIMessage.h

#ifndef MPI_CoreToCoreIMessage_H
#define MPI_CoreToCoreIMessage_H
 
//inherited class header
#include "MPI_CoreToCoreMessage.h"
 
template<typename T>
class MPI_CoreToCoreIMessage : public MPI_CoreToCoreMessage<T>  {
   
    //attributes
private :
    
    //UML inheritance classes
    typedef MPI_CoreToCoreIMessage<T> SelfClass;
    typedef MPI_CoreToCoreMessage<T> SuperClass;
 
    //state attributes
    tUCInt mRequestsNumber;
    tMPIRequest mRequests[2];
    tMPIStatus mStatus;
    T* mReplacedValues;
    std::valarray<T> mBuffer;
        
public:
    // CONSTRUCTORS 
    MPI_CoreToCoreIMessage() {
        mRequestsNumber=1;
        mReplacedValues=null;
    }
  
    // DESTRUCTORS 
    virtual ~MPI_CoreToCoreIMessage(void) {
       
    }
 
public:
    
    inline static CORE_UniquePointer<SelfClass> New() {
        CORE_UniquePointer<SelfClass> p(new SelfClass(),CORE_Object::Delete());
        return p;
    };
    
    //memory management
    //=================
    virtual tMemSize getMemorySize() const override{
        return sizeof(*this)+this->getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const override {
        return SuperClass::getContentsMemorySize();
    }
    //sender methods
    //===============
   
    //primary type variable
    //----------------------
    
    inline static void Send(const MPI_Environment& env,const tMPICoreId& dstCore,
                            const T& data,const tMPITag& tag,
                            tMPIRequest& request) {
        MPI_Isend(&data,1,MPI_Type::GetPrimaryType<T>(),dstCore,tag,env.getWorld(),&request);
    }
    
    
    //pointer of primary type
    //------------------------
    
    inline static void Send(const MPI_Environment& env,const tMPICoreId& dstCore,
                            const T* data,const tMPICount& nData,const tMPITag& tag,
                            tMPIRequest& request) {
        MPI_Isend(data,nData,MPI_Type::GetPrimaryType<T>(),dstCore,tag,env.getWorld(),&request);
    }
   
 
    //valarray primary type
    //---------------------
    inline static void Send(const MPI_Environment& env,const tMPICoreId& dstCore,
                            const std::valarray<T>& data,const tMPITag& tag,
                            tMPIRequest& request) {
        MPI_Isend(&data[0],data.size(),MPI_Type::GetPrimaryType<T>(),dstCore,tag,env.getWorld(),&request);
    }
    
    virtual  void send(const MPI_Environment& env,const tMPICoreId& dstCore,
                       const std::valarray<T>& data,const tMPITag& tag) override {
        mRequestsNumber=1;
        Send(env,dstCore,data,tag,mRequests[0]);
    }
    
 
    
 
    //MPI type
    //--------
    virtual void send(const MPI_Environment& env,const tMPICoreId& dstCore,
                      const T* data,const tMPICount& nData,const tMPIType& dataType,const tMPITag& tag) override {
        Send(env,dstCore,data,nData,dataType,tag,mRequests[0]);
    }
    
    inline static void Send(const MPI_Environment& env,const tMPICoreId& dstCore,
                            const T* data,const tMPICount& nData,const tMPIType& dataType,const tMPITag& tag,
                            tMPIRequest&  request) {
        MPI_Isend(data,nData,dataType,dstCore,tag,env.getWorld(),&request);
    }
   
 
 
    //receive methods
    //===============
  
    //primary type variable
    //----------------------
    inline static tBoolean Receive(const MPI_Environment& env,
                                   const tMPICoreId& srcCore,T& data,const tMPITag& tag,
                                   tMPIRequest& request) {
        MPI_Irecv(&data,1,MPI_Type::GetPrimaryType<T>(),srcCore,tag,env.getWorld(),&request);
        return true;
    }
 
    //valarray primary type
    //---------------------
 
    inline static tBoolean Receive(const MPI_Environment& env,const tMPICoreId& srcCore,
                                   std::valarray<T>& data,const tMPITag& tag,
                                   tMPIRequest& request) {
        MPI_Irecv(&data[0],data.size(),MPI_Type::GetPrimaryType<T>(),srcCore,tag,env.getWorld(),&request);
        return true;
    }
   
 
    virtual void receive(const MPI_Environment& env,const tMPICoreId& srcCore,
                         std::valarray<T>& data,const tMPITag& tag) override {
        mRequestsNumber=1;
        Receive(env,srcCore,data,tag,mRequests[0]);
        
    }   
   
   
   
    
    //pointer of primary type
    //------------------------
 
    
    inline static void Receive(const MPI_Environment& env,const tMPICoreId& srcCore,
                               T* buffer,const tMPICount& nData,const tMPITag& tag,
                               tMPIRequest& request ) {
        MPI_Irecv(buffer,nData,MPI_Type::GetPrimaryType<T>(),srcCore,tag,env.getWorld(),&request);
    }
 
    
  
    
    
    
    //MPI type
    //--------
 
    
    inline static void Receive(const MPI_Environment& env,const tMPICoreId& dstCore,
                               T* buffer,const tMPICount& nData,const tMPIType& dataType,const tMPITag& tag,tMPIRequest& request) {
        MPI_Irecv(buffer,nData,dataType,dstCore,tag,env.getWorld(),&request);
    }
    
  
    virtual void receive(const MPI_Environment& env,const tMPICoreId& dstCore,
                         T* buffer,const tMPICount& nData,const tMPIType& dataType,const tMPITag& tag) override {
        Receive(env,dstCore,buffer,nData,dataType,tag,mRequests[0]);
    }
 
    
    //send & receive methods
    //=======================
  
    //primary type variable
    //----------------------
    
    inline static void SendNReceive(const MPI_Environment& env,const tMPICoreId& dstCore,const tMPICoreId& srcCore,
                                    const T& sentData,const tMPITag& sentTag,
                                    T& receivedData,const tMPITag& receivedTag,
                                    tMPIRequest requests[2]) {
        
 
        Send(env,dstCore,sentData,sentTag,requests[0]);
        Receive(env,srcCore,receivedData,receivedTag,requests[1]);
       
      
    }
    virtual void sendNReceive(const MPI_Environment& env,const tMPICoreId& dstCore,const tMPICoreId& srcCore,
                              const T& sentData,const tMPITag& sentTag,
                              T& receivedData,const tMPITag& receivedTag) override {
        mRequestsNumber=2;
        SendNReceive(env,dstCore,srcCore,
                     sentData,sentTag,
                     receivedData,receivedTag,mRequests);
    }
    
    //pointer of primary type
    //------------------------
  
 
    
    inline static void SendNReceive(const MPI_Environment& env,const tMPICoreId& dstCore,
                                    const T* sentData,const int& nSentData,const tMPITag& sentTag,
                                    T* receivedData,const int& nReceivedData,const tMPITag& receivedTag,
                                    tMPIRequest requests[2]) {
        ASSERT_IN(sentData!=receivedData);
        ASSERT_IN(nSentData==nReceivedData);
 
        Send(env,dstCore,sentData,nSentData,sentTag,requests[0]);
        Receive(env,dstCore,receivedData,nReceivedData,receivedTag,requests[1]);
        
        // MPI_Isendrecv(sentData,nSentData,MPI_Type::GetPrimaryType<T>(),
        //              dstCore,sentTag,
        //              receivedData,nReceivedData,MPI_Type::GetPrimaryType<T>(),
        //              dstCore,receivedTag,
        //              env.getWorld(),requests[0]);
        
    }
    
  
    
    
    //valarray primary type
    //---------------------
 
    
    inline static void SendNReceive(const MPI_Environment& env,const tMPICoreId& dstCore,const tMPICoreId& srcCore,
                                    const std::valarray<T>& sentData,const tMPITag& sentTag,
                                    std::valarray<T>& receivedData,const tMPITag& receivedTag,
                                    tMPIRequest requests[2]) {
        
        ASSERT_IN(&sentData!=&receivedData);
        if (receivedData.size()<sentData.size()) receivedData.resize( sentData.size());
 
        Send(env,dstCore,sentData,sentTag,requests[0]);
        Receive(env,srcCore,receivedData,receivedTag,requests[1]);
       
        
        // MPI_Isendrecv(&sentData[0],sentData.size(),MPI_Type::GetPrimaryType<T>(),
        //              dstCore,sentTag,
        //              &receivedData[0],receivedData.size(),MPI_Type::GetPrimaryType<T>(),
        //              srcCore,receivedTag,
        //              env.getWorld(),&request);
        
    }
 
    
    
    virtual void sendNReceive(const MPI_Environment& env,const tMPICoreId& dstCore,const tMPICoreId& srcCore,
                              const std::valarray<T>& sentData,const tMPITag& sentTag,
                              std::valarray<T>& receivedData,const tMPITag& receivedTag) override {
        mRequestsNumber=2;
        SendNReceive(env,dstCore,srcCore,
                     sentData,sentTag,
                     receivedData,receivedTag,mRequests);
    }
    
    
    //MPI type
    //--------
 
 
    inline static void SendNReceive(const MPI_Environment& env,const tMPICoreId& dstCore,const tMPICoreId& srcCore,
                                    const T*  sentData,const tMPICount& nSentData,const tMPIType& sentDataType,const tMPITag& sentTag,
                                    T* receivedData,const tMPICount& nReceivedData,const tMPIType& receivedDataType,const tMPITag& receivedTag,
                                    tMPIRequest requests[2])  {
        ASSERT_IN(&sentData!=&receivedData);
        Send(env,dstCore,sentData,nSentData,sentDataType,sentTag,requests[0]);
        Receive(env,srcCore,receivedData,nReceivedData,receivedDataType,receivedTag,requests[1]);
       
        // MPI_Isendrecv(&sentData[0],nSentData,sentDataType,
        //               dstCore,sentTag,
        //               &receivedData[0],nReceivedData,receivedDataType,
        //               srcCore,receivedTag,
        //               env.getWorld(),&request);
        
    }
    
    inline static void SendNReceive(const MPI_Environment& env,const tMPICoreId& dstCore,
                                    const T*  sentData,const tMPICount& nSentData,const tMPIType& sentDataType,const tMPITag& sentTag,
                                    T* receivedData,const tMPICount& nReceivedData,const tMPIType& receivedDataType,const tMPITag& receivedTag,
                                    tMPIRequest requests[2])  {
        ASSERT_IN(&sentData!=&receivedData);
        Send(env,dstCore,sentData,nSentData,sentDataType,sentTag,requests[0]);
        Receive(env,dstCore,receivedData,nReceivedData,receivedDataType,receivedTag,requests[1]);
        
        // MPI_Isendrecv(&sentData[0],nSentData,sentDataType,
        //               dstCore,sentTag,
        //               &receivedData[0],nReceivedData,receivedDataType,
        //               dstCore,receivedTag,
        //               env.getWorld(),&request);
        
    }
    
      
    virtual void sendNReceive(const MPI_Environment& env,const tMPICoreId& dstCore,const tMPICoreId& srcCore,
                              const T*  sentData,const tMPICount& nSentData,const tMPIType& sentDataType,const tMPITag& sentTag,
                              T* receivedData,const tMPICount& nReceivedData,const tMPIType& receivedDataType,const tMPITag& receivedTag) override {
        mRequestsNumber=2;
        SendNReceive(env,dstCore,srcCore,
                     sentData,nSentData,sentDataType,sentTag,
                     receivedData,nReceivedData,receivedDataType,receivedTag,
                     mRequests);
    }
    
    //exchange methods
    //=======================
  
    //primary type variable
    //----------------------
 
    
    //pointer of primary type
    //------------------------
 
       
    //valarray primary type
    //---------------------
    
    virtual void exchange(const MPI_Environment& env,const tMPICoreId& dstCore,
                          std::valarray<T>& data,const tMPITag& tag) override {
        
        // MPI_Isendrecv_replace(data,nData,dataType,
        //                      dstCore,tag,
        //                      dstCore,tag,
        //                      env.getWorld(),MPI_STATUS_IGNORE);
 
        mRequestsNumber=2;
        Send(env,dstCore,data,tag,mRequests[0]);
        
        if (mBuffer.size()!=data.size()) mBuffer.resize(data.size());
        Receive(env,dstCore,mBuffer,tag,mRequests[1]);
 
        mReplacedValues=&data[0];
        
    }
      
        
    
    //MPI type
    //--------
 
 
 
 
    virtual int wait() override {
       
        int i=0;
        switch (mRequestsNumber) {
        case 2:
            i=MPI_Wait(&mRequests[1],&mStatus);
            
        case 1:
            i=MPI_Wait(&mRequests[0],&mStatus);
            
        }
        if (mReplacedValues!=null) {
 
            memcpy(mReplacedValues,&mBuffer[0],mBuffer.size()*sizeof(T));
            
            mReplacedValues=null;
        }
        return i;
    } 
    
    virtual void getElementsNumber(tMPICount& nElements)  override {
        MPI_Wait(&mRequests[0],&mStatus);
        MPI_Get_count(&mStatus,MPI_Type::GetPrimaryType<T>(),&nElements);
    }
    
  
  
    virtual tBoolean isFinished() override { 
        int isFinished;
        tBoolean ok=true;
        for (tUCInt i=0;i<mRequestsNumber;i++) {
            MPI_Test(&mRequests[i],&isFinished,&mStatus);
            ok=ok && (isFinished==1);
        }
        if (ok) {
            if (mReplacedValues!=null) {
                memcpy(mReplacedValues,&mBuffer[0],mBuffer.size()*sizeof(T));   
                mReplacedValues=null;
            }
        }
        return ok;
    }
};
 
#endif