---

MPIComm.h

Go to the documentation of this file.

#ifndef MPICOMM_H
#define MPICOMM_H

#include "SundanceDefs.h"
#include "TSFArray.h"
#include "TSFSmartPtr.h"

#ifdef HAVE_MPI
#include "mpi.h"
#endif





namespace Sundance
{
  using namespace TSF;

  /** \ingroup MPI
   * Object representation of an MPI communicator.
   *
   * At present, groups are not implemented so the only communicator
   * is MPI_COMM_WORLD.
   */
  class MPIComm
    {
#ifdef USE_MPI_GROUPS
      friend class MPIGroup;
#endif
    public:
      /** empty ctor builds an object for MPI_COMM_WORLD */
      MPIComm();

#ifdef HAVE_MPI
      /** construct a MPIComm for a given MPI communicator */
      MPIComm(MPI_Comm comm);
#endif

      /** get an object representing MPI_COMM_WORLD */
      static MPIComm& world();

#ifdef USE_MPI_GROUPS
      /** get a subcommunicator from a parent */
      MPIComm(const MPIComm& parent, const MPIGroup& group);
#endif

      /** common initialization function, called by all ctors */
      void init();

      /** call MPI_Init */
      static void init(int* argc, void*** argv);

      /** call MPI_Finalize */
      static void finalize();

      /** return process rank */
      int getRank() const {return myRank_;}

      /** return number of processors in the communicator */
      int getNProc() const {return nProc_;}

      /** get the name of the machine on which this process is running */
      string getMachineName() const ;

      /** synchronize all the processors in the communicator */
      void synchronize() const ;

      /** \name Point to point communications */
      //@{
      /** blocking send */
      void send(void* msg, int length, int type, int tag, int dest) const ;
      /** blocking recv */
      int recv(void* msg, int length, int type, int tag, int src) const ;
      /** non-blocking recv */
      int irecv(void* msg, int length, int type, int tag, int src) const ;

      /** shut off a pending irecv */
      void disableIrecv(int proc) const ;
      void wait(int handler) const ;
      int testAny() const ;
      int waitAny() const ;
      void bcast(void* msg, int length, int type, int src) const ;
      //@}

      /** {\bf Collective communications} */
      //@{
      /** all-to-all gather-scatter */
      void allToAll(void* sendBuf, int sendCount, int sendType,
                    void* recvBuf, int recvCount, int recvType) const ;
      /** variable-length gather-scatter */
      void allToAllv(void* sendBuf, int* sendCount, int* sendDisplacements,
                     int sendType,
                     void* recvBuf, int* recvCount,
                     int* recvDisplacements,
                     int recvType) const ;

      /** do a collective operation, scattering the results to all procs */
      void allReduce(void* input, void* result, int inputCount, int type,
                     int op) const ;

      /** gather to root */
      void gather(void* sendBuf, int sendCount, int sendType,
                  void* recvBuf, int recvCount, int recvType,
                  int root) const ;

      /** gather to all procs */
      void allGather(void* sendBuf, int sendCount, int sendType,
                     void* recvBuf, int recvCount, int recvType) const ;

      /** gather to all procs */
      void allGatherv(void* sendBuf, int sendCount, int sendType,
                      void* recvBuf, int* recvCount, int* recvDisplacements,
                      int recvType) const ;

      //@}

#ifdef HAVE_MPI
      /** get the MPI_Comm communicator handle */
      MPI_Comm getComm() const {return comm_;}


      MPI_Request* getRequestTSFArray() const {return (MPI_Request*) &((*req_)[0]);}
      MPI_Request getRequest(int pid) const {return (*req_)[pid];}
      void setRequest(int pid, MPI_Request req) const {(*req_)[pid] = req;}
#endif

      /** \name Constants */
      //@{
      /** \name Data types  */
      //@{
      /** */
      const static int INT;
      /** */
      const static int FLOAT;
      /** */
      const static int DOUBLE;
      /** */
      const static int CHAR;
      //@}

      /** \name Operations */
      //@{
      /** */
      const static int SUM;
      /** */
      const static int MIN;
      /** */
      const static int MAX;
      /** */
      const static int PROD;
      //@}
      //@}

      // errCheck() checks the return value of an MPI call and throws
      // a ParallelException upon failure.
      static void errCheck(int errCode, const string& methodName);

#ifdef HAVE_MPI
      // getDataType converts a PMachine data type code to a MPI_Datatype
      static MPI_Datatype getDataType(int type);

      // getOp converts a PMachine operator code to a MPI_Op operator code.
      static MPI_Op getOp(int op);
#endif
    private:
#ifdef HAVE_MPI
      MPI_Comm comm_;
      mutable TSFSmartPtr<TSFArray<MPI_Request> > req_;
#endif

      int nProc_;
      int myRank_;
      static string machineName_;


    };
}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by