communicators.hh

Go to the documentation of this file.

 
#ifndef communicators_hh
#define communicators_hh
 
#include "basics.hh"
#include "using_p.hh"
 
// ********************************* forward declarations **
 
#ifdef MPICH
typedef union MPIR_HANDLE *MPI_Request;
#else
typedef struct _req *MPI_Request;
#endif
 
namespace parallel {
 
  // ************************************ MissingDataType **
 
  class MissingDataType : public concepts::ExceptionBase {};
 
 
  // *************************************** Communicator **
 
  class Communicator : public concepts::OutputOperator {
 
  public:
    virtual ~Communicator() {};
 
    virtual int rank() const = 0;
    virtual int nrank() const = 0;
 
    // receive
    virtual int receive(void *rbuf, uint cnt, uint src) = 0;
    virtual int receive(uint *rbuf, uint cnt, uint src) = 0;
    virtual int receive(Real *rbuf, uint cnt, uint src) = 0;
 
    // non-blocking operations
    virtual int nbsend(void *sbuf, uint cnt, uint* dest, uint ndest) = 0;
    virtual int nbsend(uint *sbuf, uint cnt, uint* dest, uint ndest) = 0;
    virtual int nbsend(Real *sbuf, uint cnt, uint* dest, uint ndest) = 0;
    virtual int waitall() = 0;
 
    // allgather
    virtual int allgather(void *sbuf, uint cnt, void *rbuf) = 0;
    virtual int allgather(uint *sbuf, uint cnt, uint *rbuf) = 0;
    virtual int allgather(Real *sbuf, uint cnt, Real *rbuf) = 0;
 
    // alltoall
    virtual int alltoallV(void *sbuf, int *nsdata, int *sdataoffset,
        void *rbuf, int *nrdata, int *rdataoffset) = 0;
    virtual int alltoallV(uint *sbuf, int *nsdata, int *sdataoffset,
        uint *rbuf, int *nrdata, int *rdataoffset) = 0;
 
    // barrier
    virtual int barrier() = 0;
  };
 
 
  // ********************************************* ComMPI **
 
  class ComMPI : public Communicator {
 
    class Request {
      Request   *lnk_;
      MPI_Request *request_;
      uint    nreq_;
 
    public:
      Request(Request *lnk, uint nreq);
      ~Request();
 
      MPI_Request* operator[](uint i);
      inline MPI_Request* request() {return request_;};
      inline uint nrequest() const {return nreq_;};
      inline Request* link() const {return lnk_;};
    };
 
    int rnk_;
    int nrnk_;
 
    Request *request_;
 
  protected:
    std::ostream& info(std::ostream& os) const {
      return os << "ComMPI(rank=" << rnk_ << ", nrank=" << nrnk_ << ")";
    };
 
  public:
    ComMPI(int *argc, char ***argv);
    ~ComMPI();
 
    int rank() const {return rnk_;};
    int nrank() const {return nrnk_;};
 
    // receive
    int receive(void *rbuf, uint cnt, uint src);
    int receive(uint *rbuf, uint cnt, uint src);
    int receive(Real *rbuf, uint cnt, uint src);
 
    // non-blocking operations
    int nbsend(void *sbuf, uint cnt, uint* dest, uint ndest);
    int nbsend(uint *sbuf, uint cnt, uint* dest, uint ndest);
    int nbsend(Real *sbuf, uint cnt, uint* dest, uint ndest);
    int waitall();
 
    // allgather
    int allgather(void *sbuf, uint cnt, void *rbuf);
    int allgather(uint *sbuf, uint cnt, uint *rbuf);
    int allgather(Real *sbuf, uint cnt, Real *rbuf);
 
    // alltoall
    int alltoallV(void *sndbuf, int *sndcounts, int *sdispls,
      void *recvbuf, int *recvcounts, int *rdispls);
    int alltoallV(uint *sndbuf, int *sndcounts, int *sdispls,
      uint *recvbuf, int *recvcounts, int *rdispls);
 
    // barrier
    int barrier();
  };
 
 
} // namespace parallel
 
#endif // communicators_hh