Debian Codegraph @

packages/stk/stk_unit_tests/stk_util/parallel/UnitTestCommSparse.cpp

raw
1 // Copyright 2002 - 2008, 2010, 2011 National Technology Engineering
2 // Solutions of Sandia, LLC (NTESS). Under the terms of Contract
3 // DE-NA0003525 with NTESS, the U.S. Government retains certain rights
4 // in this software.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
8 // met:
9 //
10 // * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 //
13 // * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following
15 // disclaimer in the documentation and/or other materials provided
16 // with the distribution.
17 //
18 // * Neither the name of NTESS nor the names of its contributors
19 // may be used to endorse or promote products derived from this
20 // software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 //
34
35 #include "gtest/gtest.h"
36 #include "stk_util/stk_config.h" // for STK_HAS_MPI
37 #if defined ( STK_HAS_MPI )
38
39 #include "stk_util/parallel/CommSparse.hpp" // for CommSparse, comm_recv_msg_sizes, comm_recv...
40 #include "stk_util/parallel/Parallel.hpp" // for parallel_machine_rank, parallel_machine_size
41 #include "stk_util/parallel/ParallelComm.hpp" // for CommBuffer
42 #include "stk_util/util/ReportHandler.hpp" // for ThrowRequireMsg
43 #include <memory> // for allocator_traits<>::value_type
44 #include <ostream> // for basic_ostream::operator<<, operator<<, bas...
45 #include <vector> // for vector
46
47 TEST(ParallelComm, CommSparse_pair_with_string)
48 {
49 stk::ParallelMachine comm = MPI_COMM_WORLD;
50 if (stk::parallel_machine_size(comm) != 2) { GTEST_SKIP(); }
51 int myRank = stk::parallel_machine_rank(comm);
52 int otherRank = 1 - myRank;
53
54 stk::CommSparse commSparse(comm);
55
56
57 const bool needToUnpackRecvdMessage =
58 stk::pack_and_communicate(commSparse, [&commSparse, &myRank, &otherRank]() {
59 std::string str = "message from "+std::to_string(myRank)+" to "+std::to_string(otherRank);
60 std::pair<std::string,int> pairToSend(str,myRank);
61 commSparse.send_buffer(otherRank).pack(pairToSend);
62 });
63
64 EXPECT_TRUE(needToUnpackRecvdMessage);
65
66 stk::CommBuffer& buf = commSparse.recv_buffer(otherRank);
67 EXPECT_TRUE(buf.remaining() > 0);
68
69 std::pair<std::string,int> expected("message from "+std::to_string(otherRank)+" to "+std::to_string(myRank),otherRank);
70 std::pair<std::string,int> recvdPair;
71 buf.unpack(recvdPair);
72 EXPECT_EQ(expected, recvdPair);
73 }
74
75 TEST(ParallelComm, CommSparse)
76 {
77 stk::ParallelMachine comm = MPI_COMM_WORLD;
78 int numProcs = stk::parallel_machine_size(comm);
79 if (numProcs == 1) {
80 GTEST_SKIP();
81 }
82
83 int myProc = stk::parallel_machine_rank(comm);
84 int numOtherProcs = 2;
85 int numItems = 20;
86
87 stk::parallel_machine_barrier(comm);
88
89 stk::CommSparse commsparse(comm);
90
91 for(int phase = 0; phase < 2; ++phase) {
92 for(int proc=myProc-numOtherProcs/2; proc<=myProc+numOtherProcs/2; ++proc) {
93 if (proc >= 0 && proc != myProc && proc < numProcs) {
94 stk::CommBuffer& proc_buff = commsparse.send_buffer(proc);
95 for(int i=0; i<numItems; ++i) {
96 proc_buff.pack<double>(myProc+1+i);
97 }
98 }
99 }
100
101 if (phase == 0) {
102 commsparse.allocate_buffers();
103 }
104 else {
105 commsparse.communicate();
106 }
107 }
108
109 for(int proc=0; proc<numProcs; ++proc) {
110 if (proc != myProc && (proc >= myProc-numOtherProcs/2) && (proc <= myProc+numOtherProcs/2)) {
111 stk::CommBuffer& proc_buff = commsparse.recv_buffer(proc);
112
113 int remaining = proc_buff.remaining()/sizeof(double);
114 EXPECT_EQ(numItems, remaining);
115
116 for(int i=0; i<numItems; ++i) {
117 double val = 0;
118 proc_buff.unpack<double>(val);
119 double expected = proc+1+i;
120 EXPECT_EQ(expected, val);
121 }
122 }
123 else {
124 stk::CommBuffer& proc_buff = commsparse.recv_buffer(proc);
125
126 int remaining = proc_buff.remaining();
127 EXPECT_EQ(0, remaining);
128 }
129 }
130 }
131
132 TEST(ParallelComm, CommSparse_all_including_self)
133 {
134 stk::ParallelMachine comm = MPI_COMM_WORLD;
135 int numProcs = stk::parallel_machine_size(comm);
136 if (numProcs == 1) {
137 GTEST_SKIP();
138 }
139
140 stk::CommSparse commSparse(comm);
141 int myProc = stk::parallel_machine_rank(comm);
142 stk::pack_and_communicate(commSparse, [&commSparse, &myProc, &numProcs]() {
143 for(int destProc=0; destProc<numProcs; ++destProc) {
144 commSparse.send_buffer(destProc).pack(myProc);
145 }
146 });
147
148 for(int srcProc=0; srcProc<numProcs; ++srcProc) {
149 stk::CommBuffer& srcBuf = commSparse.recv_buffer(srcProc);
150 EXPECT_EQ(sizeof(int), static_cast<unsigned>(srcBuf.remaining()));
151 int msg;
152 srcBuf.unpack(msg);
153 EXPECT_EQ(msg, srcProc);
154 }
155 }
156
157 TEST(ParallelComm, CommSparse_set_procs)
158 {
159 stk::ParallelMachine comm = MPI_COMM_WORLD;
160 int numProcs = stk::parallel_machine_size(comm);
161 if (numProcs == 1) {
162 GTEST_SKIP();
163 }
164
165 int myProc = stk::parallel_machine_rank(comm);
166 int numOtherProcs = 2;
167 int numItems = 20;
168
169 stk::parallel_machine_barrier(comm);
170
171 stk::CommSparse commsparse(comm);
172
173 std::vector<int> send_procs, recv_procs;
174
175 for(int phase = 0; phase < 2; ++phase) {
176 for(int proc=myProc-numOtherProcs/2; proc<=myProc+numOtherProcs/2; ++proc) {
177 if (proc >= 0 && proc != myProc && proc < numProcs) {
178 stk::CommBuffer& proc_buff = commsparse.send_buffer(proc);
179 send_procs.push_back(proc);
180 recv_procs.push_back(proc);
181 for(int i=0; i<numItems; ++i) {
182 proc_buff.pack<double>(myProc+1+i);
183 }
184 }
185 }
186
187 if (phase == 0) {
188 commsparse.allocate_buffers(send_procs, recv_procs);
189 }
190 else {
191 commsparse.communicate();
192 }
193 }
194
195 for(int proc=0; proc<numProcs; ++proc) {
196 if (proc != myProc && (proc >= myProc-numOtherProcs/2) && (proc <= myProc+numOtherProcs/2)) {
197 stk::CommBuffer& proc_buff = commsparse.recv_buffer(proc);
198
199 int remaining = proc_buff.remaining()/sizeof(double);
200 EXPECT_EQ(numItems, remaining);
201
202 for(int i=0; i<numItems; ++i) {
203 double val = 0;
204 proc_buff.unpack<double>(val);
205 double expected = proc+1+i;
206 EXPECT_EQ(expected, val);
207 }
208 }
209 else {
210 stk::CommBuffer& proc_buff = commsparse.recv_buffer(proc);
211
212 int remaining = proc_buff.remaining();
213 EXPECT_EQ(0, remaining);
214 }
215 }
216 }
217
218 TEST(ParallelComm, CommSparse_pack_and_communicate)
219 {
220 stk::ParallelMachine comm = MPI_COMM_WORLD;
221 stk::CommSparse commSparse(comm);
222 const int numProcs = commSparse.parallel_size();
223 if (numProcs == 1) { GTEST_SKIP(); }
224 const int myProc = commSparse.parallel_rank();
225 const int destProc = myProc+1 == numProcs ? 0 : myProc+1;
226 const int srcProc = myProc-1 < 0 ? numProcs-1 : myProc-1;
227
228 stk::pack_and_communicate(commSparse, [&commSparse, &destProc, &myProc]() {
229 commSparse.send_buffer(destProc).pack(myProc);
230 });
231
232 stk::unpack_communications(commSparse, [&commSparse, &srcProc](int fromProc) {
233 if (fromProc == srcProc) {
234 int recvData = -1;
235 commSparse.recv_buffer(fromProc).unpack(recvData);
236 EXPECT_EQ(srcProc, recvData);
237 }
238 });
239 }
240
241 TEST(ParallelComm, CommSparse_empty)
242 {
243 stk::ParallelMachine comm = MPI_COMM_WORLD;
244 stk::CommSparse commSparse(comm);
245 const int numProcs = commSparse.parallel_size();
246 if (numProcs == 1) { GTEST_SKIP(); }
247 commSparse.allocate_buffers();
248 commSparse.communicate_with_unpack([](int, stk::CommBuffer&) {
249 FAIL() << "expected no messages to unpack";
250 });
251 }
252
253 TEST(ParallelComm, CommSparse_communicate_with_unpack)
254 {
255 stk::ParallelMachine comm = MPI_COMM_WORLD;
256 stk::CommSparse commSparse(comm);
257 const int numProcs = commSparse.parallel_size();
258 if (numProcs == 1) { GTEST_SKIP(); }
259 const int myProc = commSparse.parallel_rank();
260 const int destProc = myProc+1 == numProcs ? 0 : myProc+1;
261 const int srcProc = myProc-1 < 0 ? numProcs-1 : myProc-1;
262
263 commSparse.send_buffer(destProc).pack(myProc);
264 commSparse.allocate_buffers();
265 commSparse.send_buffer(destProc).pack(myProc);
266
267 commSparse.communicate_with_unpack([&srcProc](int fromProc, stk::CommBuffer& buf) {
268 if (fromProc == srcProc) {
269 int recvData = -1;
270 buf.unpack(recvData);
271 EXPECT_EQ(srcProc, recvData);
272 }
273 });
274 }
275
276 TEST(ParallelComm, CommSparse_communicate_with_extra_work)
277 {
278 stk::ParallelMachine comm = MPI_COMM_WORLD;
279 stk::CommSparse commSparse(comm);
280 const int numProcs = commSparse.parallel_size();
281 if (numProcs == 1) { GTEST_SKIP(); }
282 const int myProc = commSparse.parallel_rank();
283 const int destProc = myProc+1 == numProcs ? 0 : myProc+1;
284
285 commSparse.send_buffer(destProc).pack(myProc);
286 commSparse.allocate_buffers();
287 commSparse.send_buffer(destProc).pack(myProc);
288
289 int myIntValue = -1;
290
291 auto extraWork = [&myIntValue]() { myIntValue = 999; };
292
293 myIntValue = -10;
294
295 commSparse.communicate_with_extra_work(extraWork);
296
297 EXPECT_EQ(999, myIntValue);
298 }
299
300 TEST(ParallelComm, CommSparse_communicate_with_extra_work_and_unpack)
301 {
302 stk::ParallelMachine comm = MPI_COMM_WORLD;
303 stk::CommSparse commSparse(comm);
304 const int numProcs = commSparse.parallel_size();
305 if (numProcs == 1) { GTEST_SKIP(); }
306 const int myProc = commSparse.parallel_rank();
307 const int destProc = myProc+1 == numProcs ? 0 : myProc+1;
308 const int srcProc = myProc-1 < 0 ? numProcs-1 : myProc-1;
309
310 commSparse.send_buffer(destProc).pack(myProc);
311 commSparse.allocate_buffers();
312 commSparse.send_buffer(destProc).pack(myProc);
313
314 int myIntValue = -1;
315
316 auto extraWork = [&myIntValue]() { myIntValue = 999; };
317
318 myIntValue = -10;
319
320 commSparse.communicate_with_extra_work_and_unpack(extraWork, [&srcProc](int fromProc, stk::CommBuffer& buf) {
321 if (fromProc == srcProc) {
322 int recvData = -1;
323 buf.unpack(recvData);
324 EXPECT_EQ(srcProc, recvData);
325 }
326 });
327
328 EXPECT_EQ(999, myIntValue);
329 }
330
331 TEST(ParallelComm, serialConstructCommSparse_forMemoryLeakCheck)
332 {
333 if (stk::parallel_machine_size(MPI_COMM_WORLD) != 1) { GTEST_SKIP(); }
334
335 {
336 stk::CommSparse comm(MPI_COMM_WORLD);
337 EXPECT_EQ(1, comm.parallel_size());
338 }
339 {
340 stk::CommSparse comm(MPI_COMM_WORLD);
341 EXPECT_EQ(1, comm.parallel_size());
342 }
343 }
344
345 #endif