root/ompi/mpi/cxx/comm.h

/* [<][>][^][v][top][bottom][index][help] */

INCLUDED FROM

DEFINITIONS

This source file includes following definitions.
  1. __mpi_interface_deprecated__
   1 // -*- c++ -*-
   2 //
   3 // Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   4 //                         University Research and Technology
   5 //                         Corporation.  All rights reserved.
   6 // Copyright (c) 2004-2005 The University of Tennessee and The University
   7 //                         of Tennessee Research Foundation.  All rights
   8 //                         reserved.
   9 // Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  10 //                         University of Stuttgart.  All rights reserved.
  11 // Copyright (c) 2004-2005 The Regents of the University of California.
  12 //                         All rights reserved.
  13 // Copyright (c) 2006-2009 Cisco Systems, Inc.  All rights reserved.
  14 // Copyright (c) 2011      FUJITSU LIMITED.  All rights reserved.
  15 // $COPYRIGHT$
  16 //
  17 // Additional copyrights may follow
  18 //
  19 // $HEADER$
  20 //
  21 
  22 class Comm_Null {
  23 #if 0 /* OMPI_ENABLE_MPI_PROFILING */
  24   //  friend class PMPI::Comm_Null;
  25 #endif
  26 public:
  27 
  28 #if 0 /* OMPI_ENABLE_MPI_PROFILING */
  29 
  30   // construction
  31   inline Comm_Null() { }
  32   // copy
  33   inline Comm_Null(const Comm_Null& data) : pmpi_comm(data.pmpi_comm) { }
  34   // inter-language operability
  35   inline Comm_Null(MPI_Comm data) : pmpi_comm(data) { }
  36 
  37   inline Comm_Null(const PMPI::Comm_Null& data) : pmpi_comm(data) { }
  38 
  39   // destruction
  40   virtual inline ~Comm_Null() { }
  41 
  42   inline Comm_Null& operator=(const Comm_Null& data) {
  43     pmpi_comm = data.pmpi_comm;
  44     return *this;
  45   }
  46 
  47   // comparison
  48   inline bool operator==(const Comm_Null& data) const {
  49     return (bool) (pmpi_comm == data.pmpi_comm); }
  50 
  51   inline bool operator!=(const Comm_Null& data) const {
  52     return (bool) (pmpi_comm != data.pmpi_comm);}
  53 
  54   // inter-language operability (conversion operators)
  55   inline operator MPI_Comm() const { return pmpi_comm; }
  56   //  inline operator MPI_Comm*() /*const JGS*/ { return pmpi_comm; }
  57   inline operator const PMPI::Comm_Null&() const { return pmpi_comm; }
  58 
  59 #else
  60 
  61   // construction
  62   inline Comm_Null() : mpi_comm(MPI_COMM_NULL) { }
  63   // copy
  64   inline Comm_Null(const Comm_Null& data) : mpi_comm(data.mpi_comm) { }
  65   // inter-language operability
  66   inline Comm_Null(MPI_Comm data) : mpi_comm(data) { }
  67 
  68   // destruction
  69   virtual inline ~Comm_Null() { }
  70 
  71  // comparison
  72   // JGS make sure this is right (in other classes too)
  73   inline bool operator==(const Comm_Null& data) const {
  74     return (bool) (mpi_comm == data.mpi_comm); }
  75 
  76   inline bool operator!=(const Comm_Null& data) const {
  77     return (bool) !(*this == data);}
  78 
  79   // inter-language operability (conversion operators)
  80   inline operator MPI_Comm() const { return mpi_comm; }
  81 
  82 #endif
  83 
  84 
  85 protected:
  86 
  87 #if 0 /* OMPI_ENABLE_MPI_PROFILING */
  88   PMPI::Comm_Null pmpi_comm;
  89 #else
  90   MPI_Comm mpi_comm;
  91 #endif
  92 
  93 
  94 };
  95 
  96 
  97 class Comm : public Comm_Null {
  98 public:
  99 
 100   typedef void Errhandler_function(Comm&, int*, ...);
 101   typedef Errhandler_function Errhandler_fn
 102         __mpi_interface_deprecated__("MPI::Comm::Errhandler_fn was deprecated in MPI-2.2; use MPI::Comm::Errhandler_function instead");
 103   typedef int Copy_attr_function(const Comm& oldcomm, int comm_keyval,
 104                                  void* extra_state, void* attribute_val_in,
 105                                  void* attribute_val_out,
 106                                  bool& flag);
 107   typedef int Delete_attr_function(Comm& comm, int comm_keyval,
 108                                    void* attribute_val,
 109                                    void* extra_state);
 110 #if !0 /* OMPI_ENABLE_MPI_PROFILING */
 111 #define _MPI2CPP_ERRHANDLERFN_ Errhandler_function
 112 #define _MPI2CPP_COPYATTRFN_ Copy_attr_function
 113 #define _MPI2CPP_DELETEATTRFN_ Delete_attr_function
 114 #endif
 115 
 116   // construction
 117   Comm();
 118 
 119   // copy
 120   Comm(const Comm_Null& data);
 121 
 122 #if 0 /* OMPI_ENABLE_MPI_PROFILING */
 123   Comm(const Comm& data) :
 124     Comm_Null(data),
 125     pmpi_comm((const PMPI::Comm&) data) { }
 126 
 127   // inter-language operability
 128   Comm(MPI_Comm data) : Comm_Null(data), pmpi_comm(data) { }
 129 
 130   Comm(const PMPI::Comm& data) :
 131     Comm_Null((const PMPI::Comm_Null&)data),
 132     pmpi_comm(data) { }
 133 
 134   operator const PMPI::Comm&() const { return pmpi_comm; }
 135 
 136   // assignment
 137   Comm& operator=(const Comm& data) {
 138     this->Comm_Null::operator=(data);
 139     pmpi_comm = data.pmpi_comm;
 140     return *this;
 141   }
 142   Comm& operator=(const Comm_Null& data) {
 143     this->Comm_Null::operator=(data);
 144     MPI_Comm tmp = data;
 145     pmpi_comm = tmp;
 146     return *this;
 147   }
 148   // inter-language operability
 149   Comm& operator=(const MPI_Comm& data) {
 150     this->Comm_Null::operator=(data);
 151     pmpi_comm = data;
 152     return *this;
 153   }
 154 
 155 #else
 156   Comm(const Comm& data) : Comm_Null(data.mpi_comm) { }
 157   // inter-language operability
 158   Comm(MPI_Comm data) : Comm_Null(data) { }
 159 #endif
 160 
 161 
 162   //
 163   // Point-to-Point
 164   //
 165 
 166   virtual void Send(const void *buf, int count,
 167                     const Datatype & datatype, int dest, int tag) const;
 168 
 169   virtual void Recv(void *buf, int count, const Datatype & datatype,
 170                     int source, int tag, Status & status) const;
 171 
 172 
 173   virtual void Recv(void *buf, int count, const Datatype & datatype,
 174                     int source, int tag) const;
 175 
 176   virtual void Bsend(const void *buf, int count,
 177                      const Datatype & datatype, int dest, int tag) const;
 178 
 179   virtual void Ssend(const void *buf, int count,
 180                      const Datatype & datatype, int dest, int tag) const ;
 181 
 182   virtual void Rsend(const void *buf, int count,
 183                      const Datatype & datatype, int dest, int tag) const;
 184 
 185   virtual Request Isend(const void *buf, int count,
 186                         const Datatype & datatype, int dest, int tag) const;
 187 
 188   virtual Request Ibsend(const void *buf, int count, const
 189                          Datatype & datatype, int dest, int tag) const;
 190 
 191   virtual Request Issend(const void *buf, int count,
 192                          const Datatype & datatype, int dest, int tag) const;
 193 
 194   virtual Request Irsend(const void *buf, int count,
 195                          const Datatype & datatype, int dest, int tag) const;
 196 
 197   virtual Request Irecv(void *buf, int count,
 198                         const Datatype & datatype, int source, int tag) const;
 199 
 200   virtual bool Iprobe(int source, int tag, Status & status) const;
 201 
 202   virtual bool Iprobe(int source, int tag) const;
 203 
 204   virtual void Probe(int source, int tag, Status & status) const;
 205 
 206   virtual void Probe(int source, int tag) const;
 207 
 208   virtual Prequest Send_init(const void *buf, int count,
 209                              const Datatype & datatype, int dest,
 210                              int tag) const;
 211 
 212   virtual Prequest Bsend_init(const void *buf, int count,
 213                               const Datatype & datatype, int dest,
 214                               int tag) const;
 215 
 216   virtual Prequest Ssend_init(const void *buf, int count,
 217                               const Datatype & datatype, int dest,
 218                               int tag) const;
 219 
 220   virtual Prequest Rsend_init(const void *buf, int count,
 221                               const Datatype & datatype, int dest,
 222                               int tag) const;
 223 
 224   virtual Prequest Recv_init(void *buf, int count,
 225                              const Datatype & datatype, int source,
 226                              int tag) const;
 227 
 228   virtual void Sendrecv(const void *sendbuf, int sendcount,
 229                         const Datatype & sendtype, int dest, int sendtag,
 230                         void *recvbuf, int recvcount,
 231                         const Datatype & recvtype, int source,
 232                         int recvtag, Status & status) const;
 233 
 234   virtual void Sendrecv(const void *sendbuf, int sendcount,
 235                         const Datatype & sendtype, int dest, int sendtag,
 236                         void *recvbuf, int recvcount,
 237                         const Datatype & recvtype, int source,
 238                         int recvtag) const;
 239 
 240   virtual void Sendrecv_replace(void *buf, int count,
 241                                 const Datatype & datatype, int dest,
 242                                 int sendtag, int source,
 243                                 int recvtag, Status & status) const;
 244 
 245   virtual void Sendrecv_replace(void *buf, int count,
 246                                 const Datatype & datatype, int dest,
 247                                 int sendtag, int source,
 248                                 int recvtag) const;
 249 
 250   //
 251   // Groups, Contexts, and Communicators
 252   //
 253 
 254   virtual Group Get_group() const;
 255 
 256   virtual int Get_size() const;
 257 
 258   virtual int Get_rank() const;
 259 
 260   static int Compare(const Comm & comm1, const Comm & comm2);
 261 
 262   virtual Comm& Clone() const = 0;
 263 
 264   virtual void Free(void);
 265 
 266   virtual bool Is_inter() const;
 267 
 268 
 269   //
 270   // Collective Communication
 271   //
 272   // Up in Comm because as of MPI-2, they are common to intracomm and
 273   // intercomm -- with the exception of Scan and Exscan, which are not
 274   // defined on intercomms.
 275   //
 276 
 277   virtual void
 278   Barrier() const;
 279 
 280   virtual void
 281   Bcast(void *buffer, int count,
 282         const Datatype& datatype, int root) const;
 283 
 284   virtual void
 285   Gather(const void *sendbuf, int sendcount,
 286          const Datatype & sendtype,
 287          void *recvbuf, int recvcount,
 288          const Datatype & recvtype, int root) const;
 289 
 290   virtual void
 291   Gatherv(const void *sendbuf, int sendcount,
 292           const Datatype & sendtype, void *recvbuf,
 293           const int recvcounts[], const int displs[],
 294           const Datatype & recvtype, int root) const;
 295 
 296   virtual void
 297   Scatter(const void *sendbuf, int sendcount,
 298           const Datatype & sendtype,
 299           void *recvbuf, int recvcount,
 300           const Datatype & recvtype, int root) const;
 301 
 302   virtual void
 303   Scatterv(const void *sendbuf, const int sendcounts[],
 304            const int displs[], const Datatype & sendtype,
 305            void *recvbuf, int recvcount,
 306            const Datatype & recvtype, int root) const;
 307 
 308   virtual void
 309   Allgather(const void *sendbuf, int sendcount,
 310             const Datatype & sendtype, void *recvbuf,
 311             int recvcount, const Datatype & recvtype) const;
 312 
 313   virtual void
 314   Allgatherv(const void *sendbuf, int sendcount,
 315              const Datatype & sendtype, void *recvbuf,
 316              const int recvcounts[], const int displs[],
 317              const Datatype & recvtype) const;
 318 
 319   virtual void
 320   Alltoall(const void *sendbuf, int sendcount,
 321            const Datatype & sendtype, void *recvbuf,
 322            int recvcount, const Datatype & recvtype) const;
 323 
 324   virtual void
 325   Alltoallv(const void *sendbuf, const int sendcounts[],
 326             const int sdispls[], const Datatype & sendtype,
 327             void *recvbuf, const int recvcounts[],
 328             const int rdispls[], const Datatype & recvtype) const;
 329 
 330   virtual void
 331   Alltoallw(const void *sendbuf, const int sendcounts[],
 332             const int sdispls[], const Datatype sendtypes[],
 333             void *recvbuf, const int recvcounts[],
 334             const int rdispls[], const Datatype recvtypes[]) const;
 335 
 336   virtual void
 337   Reduce(const void *sendbuf, void *recvbuf, int count,
 338          const Datatype & datatype, const Op & op,
 339          int root) const;
 340 
 341 
 342   virtual void
 343   Allreduce(const void *sendbuf, void *recvbuf, int count,
 344             const Datatype & datatype, const Op & op) const;
 345 
 346   virtual void
 347   Reduce_scatter(const void *sendbuf, void *recvbuf,
 348                  int recvcounts[],
 349                  const Datatype & datatype,
 350                  const Op & op) const;
 351 
 352   //
 353   // Process Creation
 354   //
 355 
 356   virtual void Disconnect();
 357 
 358   static Intercomm Get_parent();
 359 
 360   static Intercomm Join(const int fd);
 361 
 362   //
 363   // External Interfaces
 364   //
 365 
 366   virtual void Get_name(char * comm_name, int& resultlen) const;
 367 
 368   virtual void Set_name(const char* comm_name);
 369 
 370   //
 371   // Process Topologies
 372   //
 373 
 374   virtual int Get_topology() const;
 375 
 376   //
 377   // Environmental Inquiry
 378   //
 379 
 380   virtual void Abort(int errorcode);
 381 
 382   //
 383   // Errhandler
 384   //
 385 
 386   static Errhandler Create_errhandler(Comm::Errhandler_function* function);
 387 
 388   virtual void Set_errhandler(const Errhandler& errhandler);
 389 
 390   virtual Errhandler Get_errhandler() const;
 391 
 392   void Call_errhandler(int errorcode) const;
 393 
 394   //
 395   // Keys and Attributes
 396   //
 397 
 398   // Need 4 overloaded versions of this function because per the
 399   // MPI-2 spec, you can mix-n-match the C predefined functions with
 400   // C++ functions.
 401   static int Create_keyval(Copy_attr_function* comm_copy_attr_fn,
 402                            Delete_attr_function* comm_delete_attr_fn,
 403                            void* extra_state);
 404   static int Create_keyval(MPI_Comm_copy_attr_function* comm_copy_attr_fn,
 405                            MPI_Comm_delete_attr_function* comm_delete_attr_fn,
 406                            void* extra_state);
 407   static int Create_keyval(Copy_attr_function* comm_copy_attr_fn,
 408                            MPI_Comm_delete_attr_function* comm_delete_attr_fn,
 409                            void* extra_state);
 410   static int Create_keyval(MPI_Comm_copy_attr_function* comm_copy_attr_fn,
 411                            Delete_attr_function* comm_delete_attr_fn,
 412                            void* extra_state);
 413 
 414 protected:
 415   static int do_create_keyval(MPI_Comm_copy_attr_function* c_copy_fn,
 416                               MPI_Comm_delete_attr_function* c_delete_fn,
 417                               Copy_attr_function* cxx_copy_fn,
 418                               Delete_attr_function* cxx_delete_fn,
 419                               void* extra_state, int &keyval);
 420 
 421 public:
 422 
 423   static void Free_keyval(int& comm_keyval);
 424 
 425   virtual void Set_attr(int comm_keyval, const void* attribute_val) const;
 426 
 427   virtual bool Get_attr(int comm_keyval, void* attribute_val) const;
 428 
 429   virtual void Delete_attr(int comm_keyval);
 430 
 431   static int NULL_COPY_FN(const Comm& oldcomm, int comm_keyval,
 432                           void* extra_state, void* attribute_val_in,
 433                           void* attribute_val_out, bool& flag);
 434 
 435   static int DUP_FN(const Comm& oldcomm, int comm_keyval,
 436                     void* extra_state, void* attribute_val_in,
 437                     void* attribute_val_out, bool& flag);
 438 
 439   static int NULL_DELETE_FN(Comm& comm, int comm_keyval, void* attribute_val,
 440                             void* extra_state);
 441 
 442 
 443 private:
 444 #if 0 /* OMPI_ENABLE_MPI_PROFILING */
 445   PMPI::Comm pmpi_comm;
 446 #endif
 447 
 448 #if ! 0 /* OMPI_ENABLE_MPI_PROFILING */
 449 public:
 450 
 451     // Data that is passed through keyval create when C++ callback
 452     // functions are used
 453     struct keyval_intercept_data_t {
 454         MPI_Comm_copy_attr_function *c_copy_fn;
 455         MPI_Comm_delete_attr_function *c_delete_fn;
 456         Copy_attr_function* cxx_copy_fn;
 457         Delete_attr_function* cxx_delete_fn;
 458         void *extra_state;
 459     };
 460 
 461     // Protect the global list from multiple thread access
 462     static opal_mutex_t cxx_extra_states_lock;
 463 #endif
 464 
 465 };
/* [<][>][^][v][top][bottom][index][help] */