OpenMPI 0.1.1

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List
- Globals

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 };
Datatype
Definition: datatype.h:24
Comm
Definition: comm.h:97
Cartcomm
Definition: topology.h:22
Op
Definition: op.h:21
Comm_Null
Definition: comm.h:22
ompi_info_t
Definition: info.h:38
Intercomm
Definition: intercomm.h:23
Graphcomm
Definition: topology.h:99
ompi_communicator_t
Definition: communicator.h:118
Group
Definition: group.h:21
Info
Definition: info.h:22
Intracomm
Definition: intracomm.h:21