OpenMPI  0.1.1
intracomm.h
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 Cisco Systems, Inc. All rights reserved.
14 // $COPYRIGHT$
15 //
16 // Additional copyrights may follow
17 //
18 // $HEADER$
19 //
20 
21 class Intracomm : public Comm {
22 public:
23 
24  // construction
25  Intracomm() { }
26  // copy
27  Intracomm(const Comm_Null& data) : Comm(data) { }
28  // inter-language operability
29 
30 #if 0 /* OMPI_ENABLE_MPI_PROFILING */
31  //NOTE: it is extremely important that Comm(data) happens below
32  // because there is a not only pmpi_comm in this Intracomm but
33  // there is also a pmpi_comm in the inherited Comm part. Both
34  // of these pmpi_comm's need to be initialized with the same
35  // MPI_Comm object. Also the assignment operators must take this
36  // into account.
37  Intracomm(const Intracomm& data) : Comm(data), pmpi_comm(data) { }
38 
39  Intracomm(MPI_Comm data) : Comm(data), pmpi_comm(data) { }
40 
41  Intracomm(const PMPI::Intracomm& data)
42  : Comm((const PMPI::Comm&)data), pmpi_comm(data) { }
43 
44  // assignment
45  Intracomm& operator=(const Intracomm& data) {
46  Comm::operator=(data);
47  pmpi_comm = data.pmpi_comm;
48  return *this;
49  }
50  Intracomm& operator=(const Comm_Null& data) {
51  Comm::operator=(data);
52  pmpi_comm = (PMPI::Intracomm)data; return *this;
53  }
54  // inter-language operability
55  Intracomm& operator=(const MPI_Comm& data) {
56  Comm::operator=(data);
57  pmpi_comm = data;
58  return *this;
59  }
60 
61 #else
62  Intracomm(const Intracomm& data) : Comm(data.mpi_comm) { }
63 
64  inline Intracomm(MPI_Comm data);
65 
66  // assignment
67  Intracomm& operator=(const Intracomm& data) {
68  mpi_comm = data.mpi_comm; return *this;
69  }
70 
71  Intracomm& operator=(const Comm_Null& data) {
72  mpi_comm = data; return *this;
73  }
74 
75  // inter-language operability
76  Intracomm& operator=(const MPI_Comm& data) {
77  mpi_comm = data; return *this; }
78 
79 #endif
80 
81  //
82  // Collective Communication
83  //
84  // All the rest are up in comm.h -- Scan and Exscan are not defined
85  // in intercomm's, so they're down here in Intracomm.
86  //
87  virtual void
88  Scan(const void *sendbuf, void *recvbuf, int count,
89  const Datatype & datatype, const Op & op) const;
90 
91  virtual void
92  Exscan(const void *sendbuf, void *recvbuf, int count,
93  const Datatype & datatype, const Op & op) const;
94 
95  //
96  // Communicator maintenance
97  //
98 
99  Intracomm Dup() const;
100 
101  virtual Intracomm& Clone() const;
102 
103  virtual Intracomm
104  Create(const Group& group) const;
105 
106  virtual Intracomm
107  Split(int color, int key) const;
108 
109  virtual Intercomm
110  Create_intercomm(int local_leader, const Comm& peer_comm,
111  int remote_leader, int tag) const;
112 
113  virtual Cartcomm
114  Create_cart(int ndims, const int dims[],
115  const bool periods[], bool reorder) const;
116 
117  virtual Graphcomm
118  Create_graph(int nnodes, const int index[],
119  const int edges[], bool reorder) const;
120 
121 
122  //
123  // Process Creation and Management
124  //
125 
126  virtual Intercomm Accept(const char* port_name, const Info& info, int root)
127  const;
128 
129  virtual Intercomm Connect(const char* port_name, const Info& info, int root)
130  const;
131 
132  virtual Intercomm Spawn(const char* command, const char* argv[],
133  int maxprocs, const Info& info, int root) const;
134 
135  virtual Intercomm Spawn(const char* command, const char* argv[],
136  int maxprocs, const Info& info,
137  int root, int array_of_errcodes[]) const;
138 
139  virtual Intercomm Spawn_multiple(int count, const char* array_of_commands[],
140  const char** array_of_argv[],
141  const int array_of_maxprocs[],
142  const Info array_of_info[], int root);
143 
144  virtual Intercomm Spawn_multiple(int count, const char* array_of_commands[],
145  const char** array_of_argv[],
146  const int array_of_maxprocs[],
147  const Info array_of_info[], int root,
148  int array_of_errcodes[]);
149 
150 
151  //#if 0 /* OMPI_ENABLE_MPI_PROFILING */
152  // virtual const PMPI::Comm& get_pmpi_comm() const { return pmpi_comm; }
153  //#endif
154 protected:
155 
156 
157 #if 0 /* OMPI_ENABLE_MPI_PROFILING */
158  PMPI::Intracomm pmpi_comm;
159 #endif
160 
161  // Convert an array of p_nbr Info object into an array of MPI_Info.
162  // A pointer to the allocated array is returned and must be
163  // eventually deleted.
164  static inline MPI_Info *convert_info_to_mpi_info(int p_nbr,
165  const Info p_info_tbl[]);
166 };
Definition: datatype.h:24
Definition: comm.h:97
Definition: topology.h:22
Definition: op.h:21
Definition: comm.h:22
Definition: info.h:38
Definition: intercomm.h:23
Definition: topology.h:99
Definition: communicator.h:118
Definition: group.h:21
Definition: info.h:22
Definition: intracomm.h:21