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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
// Copyright Alain Miniussi 2014.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Authors: Alain Miniussi
#include <vector>
#include <iostream>
#include <sstream>
#include <iterator>
#include <algorithm>
#include <functional>
#include <boost/mpi/communicator.hpp>
#include <boost/mpi/collectives.hpp>
#include <boost/mpi/environment.hpp>
#include <boost/mpi/cartesian_communicator.hpp>
#include "mpi_test_utils.hpp"
namespace mpi = boost::mpi;
struct topo_minimum {
mpi::cartesian_dimension
operator()(mpi::cartesian_dimension const& d1,
mpi::cartesian_dimension const& d2 ) const {
return mpi::cartesian_dimension(std::min(d1.size, d2.size),
d1.periodic && d2.periodic);
}
};
std::string topology_description( mpi::cartesian_topology const& topo ) {
std::ostringstream out;
std::copy(topo.begin(), topo.end(), std::ostream_iterator<mpi::cartesian_dimension>(out, " "));
out << std::flush;
return out.str();
}
// Check that everyone agrees on the coordinates
int
test_coordinates_consistency( mpi::cartesian_communicator const& cc,
std::vector<int> const& coords )
{
int failed = 0;
cc.barrier(); // flush IOs for nice printing
bool master = cc.rank() == 0;
if (master) {
std::cout << "Test coordinates consistency.\n";
}
for(int p = 0; p < cc.size(); ++p) {
std::vector<int> min(cc.ndims());
std::vector<int> local(cc.coordinates(p));
mpi::reduce(cc, &local.front(), local.size(),
&(min[0]), mpi::minimum<int>(), p);
cc.barrier();
if (p == cc.rank()) {
BOOST_MPI_CHECK(std::equal(coords.begin(), coords.end(), min.begin()), failed);
std::ostringstream out;
out << "proc " << p << " at (";
std::copy(min.begin(), min.end(), std::ostream_iterator<int>(out, " "));
out << ")\n";
std::cout << out.str();
}
}
return failed;
}
int
test_shifted_coords( mpi::cartesian_communicator const& cc, int pos, mpi::cartesian_dimension desc, int dim )
{
int failed = 0;
if (desc.periodic) {
for (int i = -(desc.size); i < desc.size; ++i) {
std::pair<int,int> rks = cc.shifted_ranks(dim, i);
int src = cc.coordinates(rks.first)[dim];
int dst = cc.coordinates(rks.second)[dim];
if (pos == (dim/2)) {
std::ostringstream out;
out << "Rank " << cc.rank() << ", dim. " << dim << ", pos " << pos << ", in " << desc << ' ';
out << "shifted pos: " << src << ", " << dst << '\n';
std::cout << out.str();
}
}
}
return failed;
}
int
test_shifted_coords( mpi::cartesian_communicator const& cc)
{
int failed = 0;
cc.barrier(); // flush IOs for nice printing
std::vector<int> coords;
mpi::cartesian_topology topo(cc.ndims());
cc.topology(topo, coords);
bool master = cc.rank() == 0;
if (master) {
std::cout << "Testing shifts with topology " << topo << '\n';
}
for(int i = 0; i < cc.ndims(); ++i) {
if (master) {
std::cout << " for dimension " << i << ": " << topo[i] << '\n';
}
test_shifted_coords( cc, coords[i], topo[i], i );
}
return failed;
}
int
test_topology_consistency( mpi::cartesian_communicator const& cc)
{
int failed = 0;
cc.barrier(); // flush IOs for nice printing
mpi::cartesian_topology itopo(cc.ndims());
mpi::cartesian_topology otopo(cc.ndims());
std::vector<int> coords(cc.ndims());
cc.topology(itopo, coords);
bool master = cc.rank() == 0;
if (master) {
std::cout << "Test topology consistency of" << itopo << "(on master)\n";
std::cout << "Check that everyone agrees on the dimensions.\n";
}
mpi::all_reduce(cc,
&(itopo[0]), itopo.size(), &(otopo[0]),
topo_minimum());
BOOST_MPI_CHECK(std::equal(itopo.begin(), itopo.end(), otopo.begin()), failed);
if (master) {
std::cout << "We agree on " << topology_description(otopo) << '\n';
}
test_coordinates_consistency( cc, coords );
return failed;
}
int
test_cartesian_topology( mpi::cartesian_communicator const& cc)
{
int failed = 0;
BOOST_MPI_CHECK(cc.has_cartesian_topology(), failed);
for( int r = 0; r < cc.size(); ++r) {
cc.barrier();
if (r == cc.rank()) {
std::vector<int> coords = cc.coordinates(r);
std::cout << "Process of cartesian rank " << cc.rank()
<< " has coordinates (";
std::copy(coords.begin(), coords.end(), std::ostream_iterator<int>(std::cout," "));
std::cout << ")\n";
}
}
test_topology_consistency(cc);
test_shifted_coords(cc);
std::vector<int> even;
for(int i = 0; i < cc.ndims(); i += 2) {
even.push_back(i);
}
cc.barrier();
mpi::cartesian_communicator cce(cc, even);
return failed;
}
int
test_cartesian_topology( mpi::communicator const& world, mpi::cartesian_topology const& topo)
{
int failed = 0;
mpi::cartesian_communicator cc(world, topo, true);
if (cc) {
BOOST_MPI_CHECK(cc.has_cartesian_topology(), failed);
BOOST_MPI_CHECK(cc.ndims() == int(topo.size()), failed);
if (cc.rank() == 0) {
std::cout << "Asked topology " << topo << ", got " << cc.topology() << '\n';
}
test_cartesian_topology(cc);
} else {
std::ostringstream out;
out << world.rank() << " was left outside the cartesian grid\n";
std::cout << out.str();
}
return failed;
}
int main()
{
mpi::environment env;
mpi::communicator world;
int failed = 0;
int const ndim = world.size() >= 24 ? 3 : 2;
mpi::cartesian_topology topo(ndim);
typedef mpi::cartesian_dimension cd;
if (topo.size() == 3) {
topo[0] = cd(2,true);
topo[1] = cd(3,false);
topo[2] = cd(4, true);
} else {
if (world.size() >= 6) {
topo[0] = cd(2,true);
topo[1] = cd(3, false);
} else {
topo[0] = cd(1,true);
topo[1] = cd(1, false);
}
}
BOOST_MPI_COUNT_FAILED(test_cartesian_topology( world, topo), failed);
#if !defined(BOOST_NO_CXX11_DEFAULTED_MOVES)
world.barrier();
if (world.rank()==0) {
std::cout << "Testing move constructor.\n";
}
BOOST_MPI_COUNT_FAILED(test_cartesian_topology( world, std::move(topo)), failed);
#endif
return failed;
}
|
