MPI_CoreToCoreBMessage.h

#ifndef MPI_CoreToCoreBMessage_H
#define MPI_CoreToCoreBMessage_H
 
//iniherited class header
#include "MPI_Object.h"
 
//environment header
#include "MPI_Environment.h"
 
//mpi type header
#include "MPI_Type.h"
 
template<typename T>
class MPI_CoreToCoreBMessage : public MPI_Object  {
   
    //attributes
private :
    static MPI_Status mStatus;
 
    T* mBuffer;
    size_t mBufferMPISize;
    
    int mMPITSize;//MPI size of T
    int mOverHead;//over head size of T
public:
    // CONSTRUCTORS 
    MPI_CoreToCoreBMessage(const tInteger& nElements,const tInteger& nMessage) {
        mBuffer=NULL;
 
        //MPI size of T
        MPI_Type::GetSize<T>(mMPITSize);
        
        //overhead size for type T
        mOverHead=(int) (1+(MPI_BSEND_OVERHEAD*1.)/mMPITSize);
 
        //allccate the buffer to the number of nElements to send
        allocateBuffer(nElements,1);
    }
  
    // DESTRUCTORS 
    virtual ~MPI_CoreToCoreBMessage(void) {
        if (mBuffer!=NULL) {
            desallocateBuffer();
        }
    }
    
    //memory management
    //=================
    virtual tMemSize getMemorySize() const override{
        return sizeof(*this)+getContentsMemorySize();
    }
 
    inline static CORE_UniquePointer<MPI_CoreToCoreBMessage<T>> New() {
        CORE_UniquePointer<MPI_CoreToCoreBMessage<T>> p(new MPI_CoreToCoreBMessage<T>(),
                                                        CORE_Object::Delete());
        return p;
    };
    
    //sender methods
    //===============
    inline void send(const MPI_Environment& env,const tMPICoreId& dstCore,
                     const T& data,const tMPITag& flag) const {
        MPI_Bsend(&data,1,MPI_Type::GetPrimaryType<T>(),dstCore,flag,env.getWorld());
    }
    
 
    inline void allocateBuffer(const tInteger& nElements,const tInteger& nMessages) {
        if (mBuffer!=NULL) {
            desallocateBuffer();
        }
        mBufferMPISize=nMessages*(nElements+mOverHead);
        mBuffer=(T*) malloc(mBufferMPISize*sizeof(T));
        mBufferMPISize*=mMPITSize;
        
        //allocate memory
        MPI_Buffer_attach(mBuffer,mBufferMPISize);
    }
    inline void desallocateBuffer() {
        MPI_Buffer_detach(&mBuffer,&mBufferMPISize);
        mBuffer==NULL;
    }
    
    
    
 
};
 
#endif