1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
// -*- c++ -*-
//
// Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
// University Research and Technology
// Corporation. All rights reserved.
// Copyright (c) 2004-2005 The University of Tennessee and The University
// of Tennessee Research Foundation. All rights
// reserved.
// Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
// University of Stuttgart. All rights reserved.
// Copyright (c) 2004-2005 The Regents of the University of California.
// All rights reserved.
// Copyright (c) 2011 FUJITSU LIMITED. All rights reserved.
// $COPYRIGHT$
//
// Additional copyrights may follow
//
// $HEADER$
//
class Cartcomm : public Intracomm {
public:
// construction
Cartcomm() { }
// copy
Cartcomm(const Comm_Null& data) : Intracomm(data) { }
// inter-language operability
inline Cartcomm(const MPI_Comm& data);
#if 0 /* OMPI_ENABLE_MPI_PROFILING */
Cartcomm(const Cartcomm& data) : Intracomm(data), pmpi_comm(data) { }
Cartcomm(const PMPI::Cartcomm& d) :
Intracomm((const PMPI::Intracomm&)d),
pmpi_comm(d) { }
// assignment
Cartcomm& operator=(const Cartcomm& data) {
Intracomm::operator=(data);
pmpi_comm = data.pmpi_comm; return *this; }
Cartcomm& operator=(const Comm_Null& data) {
Intracomm::operator=(data);
pmpi_comm = (PMPI::Cartcomm)data; return *this; }
// inter-language operability
Cartcomm& operator=(const MPI_Comm& data) {
Intracomm::operator=(data);
pmpi_comm = data; return *this; }
#else
Cartcomm(const Cartcomm& data) : Intracomm(data.mpi_comm) { }
// assignment
Cartcomm& operator=(const Cartcomm& data) {
mpi_comm = data.mpi_comm; return *this; }
Cartcomm& operator=(const Comm_Null& data) {
mpi_comm = data; return *this; }
// inter-language operability
Cartcomm& operator=(const MPI_Comm& data) {
mpi_comm = data; return *this; }
#endif
//
// Groups, Contexts, and Communicators
//
Cartcomm Dup() const;
virtual Cartcomm& Clone() const;
//
// Groups, Contexts, and Communicators
//
virtual int Get_dim() const;
virtual void Get_topo(int maxdims, int dims[], bool periods[],
int coords[]) const;
virtual int Get_cart_rank(const int coords[]) const;
virtual void Get_coords(int rank, int maxdims, int coords[]) const;
virtual void Shift(int direction, int disp,
int &rank_source, int &rank_dest) const;
virtual Cartcomm Sub(const bool remain_dims[]) const;
virtual int Map(int ndims, const int dims[], const bool periods[]) const;
#if 0 /* OMPI_ENABLE_MPI_PROFILING */
private:
PMPI::Cartcomm pmpi_comm;
#endif
};
//===================================================================
// Class Graphcomm
//===================================================================
class Graphcomm : public Intracomm {
public:
// construction
Graphcomm() { }
// copy
Graphcomm(const Comm_Null& data) : Intracomm(data) { }
// inter-language operability
inline Graphcomm(const MPI_Comm& data);
#if 0 /* OMPI_ENABLE_MPI_PROFILING */
Graphcomm(const Graphcomm& data) : Intracomm(data), pmpi_comm(data) { }
Graphcomm(const PMPI::Graphcomm& d) :
Intracomm((const PMPI::Intracomm&)d), pmpi_comm(d) { }
// assignment
Graphcomm& operator=(const Graphcomm& data) {
Intracomm::operator=(data);
pmpi_comm = data.pmpi_comm; return *this; }
Graphcomm& operator=(const Comm_Null& data) {
Intracomm::operator=(data);
pmpi_comm = (PMPI::Graphcomm)data; return *this; }
// inter-language operability
Graphcomm& operator=(const MPI_Comm& data) {
Intracomm::operator=(data);
pmpi_comm = data; return *this; }
#else
Graphcomm(const Graphcomm& data) : Intracomm(data.mpi_comm) { }
// assignment
Graphcomm& operator=(const Graphcomm& data) {
mpi_comm = data.mpi_comm; return *this; }
Graphcomm& operator=(const Comm_Null& data) {
mpi_comm = data; return *this; }
// inter-language operability
Graphcomm& operator=(const MPI_Comm& data) {
mpi_comm = data; return *this; }
#endif
//
// Groups, Contexts, and Communicators
//
Graphcomm Dup() const;
virtual Graphcomm& Clone() const;
//
// Process Topologies
//
virtual void Get_dims(int nnodes[], int nedges[]) const;
virtual void Get_topo(int maxindex, int maxedges, int index[],
int edges[]) const;
virtual int Get_neighbors_count(int rank) const;
virtual void Get_neighbors(int rank, int maxneighbors,
int neighbors[]) const;
virtual int Map(int nnodes, const int index[],
const int edges[]) const;
#if 0 /* OMPI_ENABLE_MPI_PROFILING */
private:
PMPI::Graphcomm pmpi_comm;
#endif
};
|
