toolbox_p/communicators.hh

Go to the documentation of this file.

/* -*- c++ -*-
 * communication between the processors
 */

#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