Debian Codegraph @

packages/stk/stk_unit_tests/stk_util/parallel/UnitTestParallelComm.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/parallel/Parallel.hpp" // for parallel_machine_rank, parallel_machine_size
37
38 #ifdef STK_HAS_MPI
39
40 #include "stk_util/parallel/ParallelComm.hpp" // for CommBuffer
41 #include "stk_util/parallel/DataExchangeUnknownPatternNonBlocking.hpp"
42 #include "stk_util/parallel/DataExchangeUnknownPatternNonBlockingBuffer.hpp"
43 #include "stk_util/parallel/DataExchangeUnknownPatternBlockingBuffer.hpp"
44 #include "stk_util/parallel/DataExchangeKnownPatternNonBlocking.hpp"
45 #include "stk_util/parallel/DataExchangeKnownPatternNonBlockingBuffer.hpp"
46 #include "stk_util/parallel/DataExchangeKnownPatternUserDataNonBlocking.hpp"
47
48
49 #include <vector>
50 #include <algorithm>
51 #include <fstream>
52
53
54 namespace {
55
56 using DataExchangeBlocking = stk::DataExchangeUnknownPatternBlocking;
57 using DataExchangeNonBlocking = stk::DataExchangeUnknownPatternNonBlocking;
58 template <typename T>
59 using DataExchangeBlockingBuffer = stk::DataExchangeUnknownPatternBlockingBuffer<T>;
60 template <typename T>
61 using DataExchangeNonBlockingBuffer = stk::DataExchangeUnknownPatternNonBlockingBuffer<T>;
62 using DataExchangeBlockingCommBuffer = stk::DataExchangeUnknownPatternBlockingCommBuffer;
63 using DataExchangeNonBlockingCommBuffer = stk::DataExchangeUnknownPatternNonBlockingCommBuffer;
64
65 using DataExchangeNonBlockingKnown = stk::DataExchangeKnownPatternNonBlocking;
66 template <typename T>
67 using DataExchangeNonBlockingBufferKnown = stk::DataExchangeKnownPatternNonBlockingBuffer<T>;
68 using DataExchangeNonBlockingCommBufferKnown = stk::DataExchangeKnownPatternNonBlockingCommBuffer;
69 using DataExchangeNonBlockingPtr = stk::DataExchangeKnownPatternUserDataNonBlocking;
70
71
72 template <typename T>
73 std::vector<int> get_ranks(std::vector< std::vector<T> >& lists)
74 {
75 std::vector<int> ranks;
76 for (unsigned int i=0; i < lists.size(); ++i) {
77 if (lists[i].size() > 0) {
78 ranks.push_back(i);
79 }
80 }
81
82 return ranks;
83 }
84
85 template <typename T>
86 std::vector<std::vector<T>> copy_send_bufs(const stk::ManagedBufferBase<T>& exchanger)
87 {
88 int commSize = stk::parallel_machine_size(exchanger.get_comm());
89 std::vector< std::vector<T> > sendBufs(commSize);
90
91 for (int i=0; i < commSize; ++i)
92 {
93 auto& sendBuf = exchanger.get_send_buf(i);
94 sendBufs[i].assign(sendBuf.begin(), sendBuf.end());
95 }
96
97 return sendBufs;
98 }
99
100
101 template <typename T>
102 std::vector<std::vector<T>> copy_send_bufs(stk::ManagedCommBufferBase& exchanger)
103 {
104 int commSize = stk::parallel_machine_size(exchanger.get_comm());
105 std::vector< std::vector<T> > sendBufs(commSize);
106
107 for (int i=0; i < commSize; ++i)
108 {
109 stk::CommBuffer& sendBuf = exchanger.get_send_buf(i);
110 sendBuf.reset();
111 size_t nvals = sendBuf.capacity() / sizeof(T);
112 for (size_t j=0; j < nvals; ++j)
113 {
114 T val;
115 sendBuf.unpack(val);
116 sendBufs[i].push_back(val);
117 }
118 }
119
120 return sendBufs;
121 }
122
123
124 template <typename T>
125 std::vector<std::vector<T>> copy_recv_bufs(const stk::ManagedBufferBase<T>& exchanger)
126 {
127 int commSize = stk::parallel_machine_size(exchanger.get_comm());
128 std::vector< std::vector<T> > recvBufs(commSize);
129
130 for (int i=0; i < commSize; ++i)
131 {
132 auto& recvBuf = exchanger.get_recv_buf(i);
133 recvBufs[i].assign(recvBuf.begin(), recvBuf.end());
134 }
135
136 return recvBufs;
137 }
138
139
140 template <typename T>
141 std::vector<std::vector<T>> copy_recv_bufs(stk::ManagedCommBufferBase& exchanger)
142 {
143 int commSize = stk::parallel_machine_size(exchanger.get_comm());
144 std::vector< std::vector<T> > recvBufs(commSize);
145
146 for (int i=0; i < commSize; ++i)
147 {
148 stk::CommBuffer& recvBuf = exchanger.get_recv_buf(i);
149 size_t nvals = recvBuf.capacity() / sizeof(T);
150 for (size_t j=0; j < nvals; ++j)
151 {
152 T val;
153 recvBuf.unpack(val);
154 recvBufs[i].push_back(val);
155 }
156 }
157
158 return recvBufs;
159 }
160
161 template <typename T>
162 class ParallelCommTester
163 {
164 public:
165 using ElementType = T;
166
167 ParallelCommTester(bool split_last = false)
168 {
169
170 myrank = stk::parallel_machine_rank(MPI_COMM_WORLD);
171 commSize = stk::parallel_machine_size(MPI_COMM_WORLD);
172 if (split_last) {
173 color = myrank == commSize -1 ? 0 : 1;
174 int key = myrank;
175 MPI_Comm_split(MPI_COMM_WORLD, color, key, &comm);
176
177 myrank = stk::parallel_machine_rank(comm);
178 commSize = stk::parallel_machine_size(comm);
179 } else {
180 comm = MPI_COMM_WORLD;
181 color = 0;
182 }
183 }
184
185 virtual ~ParallelCommTester() {}
186
187 int get_value(const int rankSrc, const int rankDest, const int idx)
188 {
189 return rankSrc + 2*rankDest + 3*idx + m_offset;
190 }
191
192 int get_size(const int rankSrc, const int rankDest)
193 {
194 return m_nvalsBase + rankSrc + 2*rankDest;
195 }
196
197 virtual void set_offset(int val) { m_offset = val; }
198
199 std::vector< std::vector<T> >& get_send_lists() { return sendLists; }
200
201 std::vector< std::vector<T> >& get_receive_lists() { return recvLists; }
202
203 virtual int get_num_sends() = 0;
204
205 virtual int get_num_recvs() = 0;
206
207 MPI_Comm comm;
208 int color = -1;
209 int myrank = -1;
210 int commSize = -1;
211
212 protected:
213 std::vector< std::vector<T> > sendLists;
214 std::vector< std::vector<T> > recvLists;
215
216 private:
217 const int m_nvalsBase = 512;
218 int m_offset = 0;
219
220 };
221
222 // test communication when all processes send to all other processes
223 template <typename T>
224 class DenseParallelCommTesterBase : public ParallelCommTester<T>
225 {
226 public:
227 using ParallelCommTester<T>::sendLists;
228 using ParallelCommTester<T>::recvLists;
229 using ParallelCommTester<T>::comm;
230 using ParallelCommTester<T>::myrank;
231 using ParallelCommTester<T>::commSize;
232
233 explicit DenseParallelCommTesterBase(bool split_last = false)
234 {
235 if (split_last) { /*silly statement to get past build warning*/ }
236
237 recvLists.resize(commSize);
238 sendLists.resize(commSize);
239
240 set_send_buffers_values();
241 }
242
243 virtual ~DenseParallelCommTesterBase() {}
244
245 void set_offset(int val) override
246 {
247 ParallelCommTester<T>::set_offset(val);
248 set_send_buffers_values();
249 }
250
251 void set_recv_buffer_sizes(std::vector< std::vector<T> >& rcvLists)
252 {
253 for (int src=0; src < commSize; ++src) {
254 rcvLists[src].resize(this->get_size(src, myrank));
255 }
256 }
257
258 virtual int get_num_sends() override { return commSize; }
259
260 virtual int get_num_recvs() override { return commSize; }
261
262 void test_results(std::vector< std::vector<T> >& rcvLists)
263 {
264 for (int src=0; src < commSize; ++src) {
265 test_recv_vals(rcvLists[src], src);
266 }
267 }
268
269 void test_recv_vals(const std::vector<T>& recvList, int src)
270 {
271 size_t sizeEx = this->get_size(src, myrank);
272 EXPECT_EQ(recvList.size(), sizeEx);
273
274 if (recvList.size() == sizeEx) {
275 for (size_t j=0; j < sizeEx; ++j) {
276 EXPECT_EQ(recvList[j], this->get_value(src, myrank, j));
277 }
278 }
279 }
280
281 void test_send_ranks(std::vector< std::vector<T> >& sndLists)
282 {
283 test_ranks_inner(sndLists);
284 }
285
286
287 void test_recv_ranks(std::vector<std::vector<T>>& recvListsArg)
288 {
289 test_ranks_inner(recvListsArg);
290 }
291
292
293 private:
294 void test_ranks_inner(std::vector< std::vector<T> >& buffers)
295 {
296 auto ranks = get_ranks(buffers);
297 int len = ranks.size();
298 EXPECT_EQ(len, commSize);
299
300 for (int i=0; i < len; ++i) {
301 EXPECT_EQ(ranks[i], i);
302 }
303 }
304
305 void set_send_buffers_values()
306 {
307 for (int dest=0; dest < commSize; ++dest) {
308 int size_d = this->get_size(myrank, dest);
309 sendLists[dest].resize(size_d);
310 for (int j=0; j < size_d; ++j) {
311 sendLists[dest][j] = this->get_value(myrank, dest, j);
312 }
313 }
314 }
315 };
316
317
318 template <typename T>
319 class DenseParallelCommTester : public ::testing::Test,
320 public DenseParallelCommTesterBase<T>
321 {
322 };
323
324 using DenseParallelCommTesterInt = DenseParallelCommTester<int>;
325 using DenseParallelCommTesterDouble = DenseParallelCommTester<double>;
326
327 // test when process i only sends to i + 1 and i + 2 (with wrap around)
328 template <typename T>
329 class NeighborParallelCommTesterBase : public ParallelCommTester<T>
330 {
331 public:
332 using ParallelCommTester<T>::sendLists;
333 using ParallelCommTester<T>::recvLists;
334 using ParallelCommTester<T>::comm;
335 using ParallelCommTester<T>::myrank;
336 using ParallelCommTester<T>::commSize;
337
338 NeighborParallelCommTesterBase()
339 {
340 recvLists.resize(commSize);
341 sendLists.resize(commSize);
342
343 set_send_buffers_values();
344 }
345
346 virtual ~NeighborParallelCommTesterBase() {}
347
348 void set_offset(int val) override
349 {
350 ParallelCommTester<T>::set_offset(val);
351 set_send_buffers_values();
352 }
353
354 void set_recv_buffer_sizes(std::vector< std::vector<T> >& rcvLists)
355 {
356 int src1 = (myrank - 1 + commSize) % commSize;
357 int src2 = (myrank - 2 + commSize) % commSize;
358 rcvLists[src1].resize(this->get_size(src1, myrank));
359 rcvLists[src2].resize(this->get_size(src2, myrank));
360 }
361
362 virtual int get_num_sends() override { return std::min(2, commSize); }
363
364 virtual int get_num_recvs() override { return std::min(2, commSize); }
365
366 std::vector<int> get_dest_ranks()
367 {
368 int dest1 = (myrank + 1) % commSize;
369 int dest2 = (myrank + 2) % commSize;
370 if (dest1 == dest2)
371 {
372 return {dest1};
373 } else
374 {
375 return {dest1, dest2};
376 }
377 }
378
379 std::vector<int> get_src_ranks()
380 {
381 int src1 = (myrank - 1 + commSize) % commSize;
382 int src2 = (myrank - 2 + commSize) % commSize;
383
384 if (src1 == src2)
385 {
386 return {src1};
387 } else
388 {
389 return {src1, src2};
390 }
391 }
392
393 void test_results(std::vector< std::vector<T> >& rcvLists)
394 {
395 for (int src=0; src < commSize; ++src) {
396 test_recv_vals(rcvLists[src], src);
397 }
398 }
399
400 void test_recv_vals(const std::vector<T>& recvVals, int src)
401 {
402 int src1 = (myrank - 1 + commSize) % commSize;
403 int src2 = (myrank - 2 + commSize) % commSize;
404 size_t sizeEx = 0;
405 if (src == src1 || src == src2) {
406 sizeEx = this->get_size(src, myrank);
407 }
408
409 EXPECT_EQ(recvVals.size(), sizeEx);
410 for (size_t j=0; j < sizeEx; ++j) {
411 EXPECT_EQ(recvVals[j], this->get_value(src, myrank, j));
412 }
413 }
414
415 void test_send_ranks(std::vector<std::vector<T>>& sndLists)
416 {
417
418 std::vector<int> sendRanks = get_ranks(sndLists);
419
420 int len = sendRanks.size();
421 int dest1 = (myrank + 1) % commSize;
422 int dest2 = (myrank + 2) % commSize;
423 int nOthers = 2;
424 if (myrank == dest1) {
425 nOthers = 1;
426 }
427
428 EXPECT_EQ(len, nOthers);
429
430 std::vector<int> sendRanksEx{dest1, dest2};
431 std::sort(sendRanksEx.begin(), sendRanksEx.end());
432 for (int i=0; i < nOthers; ++i) {
433 EXPECT_EQ(sendRanks[i], sendRanksEx[i]);
434 }
435 }
436
437 void test_recv_ranks(std::vector<std::vector<T>>& rcvLists)
438 {
439 auto recvRanks = get_ranks(rcvLists);
440
441 int len = recvRanks.size();
442 int dest1 = (myrank - 1 + commSize) % commSize;
443 int dest2 = (myrank - 2 + commSize) % commSize;
444 int nOthers = 2;
445 if (dest1 == myrank && dest2 == myrank) {
446 nOthers = 1;
447 }
448
449 EXPECT_EQ(len, nOthers);
450
451 std::vector<int> recvRanksEx{dest1, dest2};
452 std::sort(recvRanksEx.begin(), recvRanksEx.end());
453 for (int i=0; i < nOthers; ++i) {
454 EXPECT_EQ(recvRanks[i], recvRanksEx[i]);
455 }
456 }
457
458 private:
459 void set_send_buffers_values()
460 {
461 int dest1 = (myrank + 1) % commSize;
462 int dest2 = (myrank + 2) % commSize;
463 int size_d1 = this->get_size(myrank, dest1);
464 int size_d2 = this->get_size(myrank, dest2);
465 sendLists[dest1].resize(size_d1);
466 sendLists[dest2].resize(size_d2);
467 for (int j=0; j < size_d1; ++j) {
468 sendLists[dest1][j] = this->get_value(myrank, dest1, j);
469 }
470
471 for (int j=0; j < size_d2; ++j) {
472 sendLists[dest2][j] = this->get_value(myrank, dest2, j);
473 }
474 }
475
476 };
477
478 template <typename T>
479 class NeighborParallelCommTester : public ::testing::Test,
480 public NeighborParallelCommTesterBase<T>
481 {
482 };
483
484 using NeighborParallelCommTesterInt = NeighborParallelCommTester<int>;
485 using NeighborParallelCommTesterDouble = NeighborParallelCommTester<double>;
486
487
488 }
489
490 //-----------------------------------------------------------------------------
491 // Test parallel_data_exchange_t
492
493 TEST_F(DenseParallelCommTesterInt, FuncBlocking)
494 {
495 for (int i=0; i < 100; ++i) {
496 stk::parallel_data_exchange_t(get_send_lists(), get_receive_lists(), comm);
497 test_results(get_receive_lists());
498 }
499 }
500
501
502 TEST_F(DenseParallelCommTesterDouble, FuncBlocking)
503 {
504 for (int i=0; i < 100; ++i) {
505 stk::parallel_data_exchange_t(get_send_lists(), get_receive_lists(), comm);
506 test_results(get_receive_lists());
507 }
508 }
509
510
511 TEST_F(NeighborParallelCommTesterInt, FuncBlocking)
512 {
513 stk::parallel_data_exchange_t(get_send_lists(), get_receive_lists(), comm);
514 test_results(get_receive_lists());
515 }
516
517
518 TEST_F(NeighborParallelCommTesterDouble, FuncBlocking)
519 {
520 stk::parallel_data_exchange_t(get_send_lists(), get_receive_lists(), comm);
521 test_results(get_receive_lists());
522 }
523
524 //-----------------------------------------------------------------------------
525 // test parallel_data_exchange_nonsym_known_sizes_t
526 TEST(NonsymKnownsizes, nominal_correct)
527 {
528 const int numProcs = stk::parallel_machine_size(MPI_COMM_WORLD);
529 if (numProcs != 4) { GTEST_SKIP(); }
530
531 std::vector<int> sendOffsets, recvOffsets;
532 std::vector<double> sendData, recvData, expectedRecvData;
533
534 const int myProc = stk::parallel_machine_rank(MPI_COMM_WORLD);
535
536 if (myProc == 2) {
537 sendOffsets = { 0, 0, 0, 0, 0 };
538 recvOffsets = { 0, 2, 4, 4, 6 }; //recving from procs 0, 1, 3
539 expectedRecvData = { 42.0, 99.0, 42.0, 99.0, 42.0, 99.0 };
540 recvData.resize(6);
541 }
542 else {
543 sendOffsets = { 0, 0, 0, 2, 2 }; //sending to proc 2
544 sendData = { 42.0, 99.0 };
545 recvOffsets = { 0, 0, 0, 0, 0 };
546 }
547
548 const bool checkInput = true;
549 EXPECT_NO_THROW(
550 stk::parallel_data_exchange_nonsym_known_sizes_t(sendOffsets.data(), sendData.data(),
551 recvOffsets.data(), recvData.data(),
552 MPI_COMM_WORLD, checkInput));
553
554 EXPECT_EQ(recvData.size(), expectedRecvData.size());
555 if (myProc == 2) {
556 EXPECT_EQ(6u, recvData.size());
557 }
558
559 for(unsigned i=0; i<recvData.size(); ++i) {
560 EXPECT_NEAR(recvData[i], expectedRecvData[i], 1.e-8);
561 }
562 }
563
564 TEST(NonsymKnownsizes, inconsistent_send_input)
565 {
566 const int numProcs = stk::parallel_machine_size(MPI_COMM_WORLD);
567 if (numProcs != 4) { GTEST_SKIP(); }
568
569 std::vector<int> sendOffsets, recvOffsets;
570 std::vector<double> sendData, recvData, expectedRecvData;
571
572 const int myProc = stk::parallel_machine_rank(MPI_COMM_WORLD);
573
574 if (myProc == 2) {
575 sendOffsets = { 0, 0, 0, 0, 0 };
576 recvOffsets = { 0, 2, 4, 4, 6 }; //recving from procs 0, 1, 3
577 expectedRecvData = { 42.0, 99.0, 42.0, 99.0, 42.0, 99.0 };
578 recvData.resize(6);
579 }
580 else if (myProc == 0) {
581 sendOffsets = { 0, 0, 1, 3, 3 }; //sending to procs 1 and 2
582 sendData = { 42.0, 99.0 };
583 recvOffsets = { 0, 0, 0, 0, 0 };
584 }
585 else {
586 sendOffsets = { 0, 0, 0, 2, 2 };
587 sendData = { 42.0, 99.0 };
588 recvOffsets = { 0, 0, 0, 0, 0 };
589 }
590
591 const bool checkInput = true;
592 EXPECT_ANY_THROW(
593 stk::parallel_data_exchange_nonsym_known_sizes_t(sendOffsets.data(), sendData.data(),
594 recvOffsets.data(), recvData.data(),
595 MPI_COMM_WORLD, checkInput));
596
597 }
598
599 TEST(NonsymKnownsizes, inconsistent_recv_input)
600 {
601 const int numProcs = stk::parallel_machine_size(MPI_COMM_WORLD);
602 if (numProcs != 4) { GTEST_SKIP(); }
603
604 std::vector<int> sendOffsets, recvOffsets;
605 std::vector<double> sendData, recvData, expectedRecvData;
606
607 const int myProc = stk::parallel_machine_rank(MPI_COMM_WORLD);
608
609 if (myProc == 2) {
610 sendOffsets = { 0, 0, 0, 0, 0 };
611 recvOffsets = { 0, 0, 2, 2, 4 }; // only recving from procs 1 and 3
612 expectedRecvData = { 42.0, 99.0, 42.0, 99.0, 42.0, 99.0 };
613 recvData.resize(6);
614 }
615 else {
616 sendOffsets = { 0, 0, 0, 2, 2 }; //sending to proc 2
617 sendData = { 42.0, 99.0 };
618 recvOffsets = { 0, 0, 0, 0, 0 };
619 }
620
621 const bool checkInput = true;
622 EXPECT_ANY_THROW(
623 stk::parallel_data_exchange_nonsym_known_sizes_t(sendOffsets.data(), sendData.data(),
624 recvOffsets.data(), recvData.data(),
625 MPI_COMM_WORLD, checkInput));
626
627 }
628
629 TEST(NonsymKnownsizes, inconsistent_msg_sizing)
630 {
631 const int numProcs = stk::parallel_machine_size(MPI_COMM_WORLD);
632 if (numProcs != 4) { GTEST_SKIP(); }
633
634 std::vector<int> sendOffsets, recvOffsets;
635 std::vector<double> sendData, recvData, expectedRecvData;
636
637 const int myProc = stk::parallel_machine_rank(MPI_COMM_WORLD);
638
639 if (myProc == 2) {
640 sendOffsets = { 0, 0, 0, 0, 0 };
641 recvOffsets = { 0, 2, 4, 4, 6 }; //recving 2 values each from procs 0, 1, 3
642 expectedRecvData = { 42.0, 99.0, 42.0, 99.0, 42.0, 99.0 };
643 recvData.resize(6);
644 }
645 else {
646 sendOffsets = { 0, 0, 0, 1, 1 }; //sending 1 value to proc 2
647 sendData = { 42.0, 99.0 };
648 recvOffsets = { 0, 0, 0, 0, 0 };
649 }
650
651 const bool checkInput = true;
652 EXPECT_ANY_THROW(
653 stk::parallel_data_exchange_nonsym_known_sizes_t(sendOffsets.data(), sendData.data(),
654 recvOffsets.data(), recvData.data(),
655 MPI_COMM_WORLD, checkInput));
656 }
657
658 //-----------------------------------------------------------------------------
659 // test ParallelDataExchange class
660
661 TEST_F(DenseParallelCommTesterInt, ClassBlocking)
662 {
663 DataExchangeBlocking exchanger(comm);
664
665 for (int i=0; i < 100; ++i) {
666 set_offset(i);
667 if (i % 2 == 0) {
668 exchanger.execute(get_send_lists(), get_receive_lists());
669 } else {
670 exchanger.execute(get_send_lists(), get_receive_lists(), get_num_recvs());
671 }
672 test_results(get_receive_lists());
673 test_send_ranks(get_send_lists());
674 test_recv_ranks(get_receive_lists());
675 }
676
677 }
678
679 TEST_F(DenseParallelCommTesterInt, ClassBlockingBuffer)
680 {
681 DataExchangeBlockingBuffer<int> exchanger(comm);
682
683 for (int i=0; i < 100; ++i) {
684 set_offset(i);
685
686 for (int j=0; j < commSize; ++j)
687 {
688 auto& buf_in = get_send_lists()[j];
689 auto& buf_out = exchanger.get_send_buf(j);
690 buf_out.assign(buf_in.begin(), buf_in.end());
691 }
692
693 if (i % 2 == 0) {
694 exchanger.execute();
695 } else {
696 exchanger.execute(get_num_recvs());
697 }
698
699
700 std::vector<std::vector<int>> send_bufs = copy_send_bufs(exchanger);
701 std::vector<std::vector<int>> recv_bufs = copy_recv_bufs(exchanger);
702
703 test_results(recv_bufs);
704 test_send_ranks(send_bufs);
705 test_recv_ranks(recv_bufs);
706
707 exchanger.clear_send_bufs();
708 exchanger.clear_recv_bufs();
709 }
710 }
711
712 TEST_F(DenseParallelCommTesterInt, ClassBlockingCommBuffer)
713 {
714 DataExchangeBlockingCommBuffer exchanger(comm);
715
716 for (int i=0; i < 100; ++i) {
717 set_offset(i);
718
719 for (int phase=0; phase < 2; ++phase) {
720 for (int j=0; j < commSize; ++j) {
721 auto& send_buf = exchanger.get_send_buf(j);
722 for (auto& val : get_send_lists()[j]) {
723 send_buf.pack(val);
724 }
725 }
726 if (phase == 0) {
727 exchanger.allocate_send_buffers();
728 }
729 }
730
731 if (i % 2 == 0) {
732 exchanger.execute();
733 } else {
734 exchanger.execute(get_num_recvs());
735 }
736
737 std::vector<std::vector<int>> send_bufs = copy_send_bufs<int>(exchanger);
738 std::vector<std::vector<int>> recv_bufs = copy_recv_bufs<int>(exchanger);
739
740 test_results(recv_bufs);
741 test_send_ranks(send_bufs);
742 test_recv_ranks(recv_bufs);
743
744 exchanger.clear_send_bufs();
745 exchanger.clear_recv_bufs();
746 }
747 }
748
749
750 TEST_F(DenseParallelCommTesterDouble, ClassBlocking)
751 {
752 DataExchangeBlocking exchanger(comm);
753
754 for (int i=0; i < 100; ++i) {
755 set_offset(i);
756 if (i % 2 == 0) {
757 exchanger.execute(get_send_lists(), get_receive_lists());
758 } else {
759 exchanger.execute(get_send_lists(), get_receive_lists(), get_num_recvs());
760 }
761
762 test_results(get_receive_lists());
763 test_send_ranks(get_send_lists());
764 test_recv_ranks(get_receive_lists());
765 }
766 }
767
768
769 TEST_F(NeighborParallelCommTesterInt, ClassBlocking)
770 {
771 DataExchangeBlocking exchanger(comm);
772 for (int i=0; i < 100; ++i) {
773 set_offset(i);
774 if (i % 2 == 0) {
775 exchanger.execute(get_send_lists(), get_receive_lists());
776 } else {
777 exchanger.execute(get_send_lists(), get_receive_lists(), get_num_recvs());
778 }
779 test_results(get_receive_lists());
780 test_send_ranks(get_send_lists());
781 test_recv_ranks(get_receive_lists());
782 }
783
784 }
785
786 TEST_F(NeighborParallelCommTesterInt, ClassBlockingBuffer)
787 {
788 DataExchangeBlockingBuffer<int> exchanger(comm);
789
790 for (int i=0; i < 100; ++i) {
791 set_offset(i);
792
793 for (int j=0; j < commSize; ++j)
794 {
795 auto& buf_in = get_send_lists()[j];
796 auto& buf_out = exchanger.get_send_buf(j);
797 buf_out.assign(buf_in.begin(), buf_in.end());
798 }
799
800 if (i % 2 == 0) {
801 exchanger.execute();
802 } else {
803 exchanger.execute(get_num_recvs());
804 }
805
806 std::vector<std::vector<int>> send_bufs = copy_send_bufs(exchanger);
807 std::vector<std::vector<int>> recv_bufs = copy_recv_bufs(exchanger);
808
809 test_results(recv_bufs);
810 test_send_ranks(send_bufs);
811 test_recv_ranks(recv_bufs);
812
813 exchanger.clear_send_bufs();
814 exchanger.clear_recv_bufs();
815 }
816 }
817
818 TEST_F(NeighborParallelCommTesterInt, ClassBlockingCommBuffer)
819 {
820 DataExchangeBlockingCommBuffer exchanger(comm);
821
822 for (int i=0; i < 100; ++i) {
823 set_offset(i);
824
825 for (int phase=0; phase < 2; ++phase) {
826 for (int j=0; j < commSize; ++j) {
827 auto& send_buf = exchanger.get_send_buf(j);
828 for (auto& val : get_send_lists()[j]) {
829 send_buf.pack(val);
830 }
831 }
832 if (phase == 0) {
833 exchanger.allocate_send_buffers();
834 }
835 }
836
837 if (i % 2 == 0) {
838 exchanger.execute();
839 } else {
840 exchanger.execute(get_num_recvs());
841 }
842
843 std::vector<std::vector<int>> send_bufs = copy_send_bufs<int>(exchanger);
844 std::vector<std::vector<int>> recv_bufs = copy_recv_bufs<int>(exchanger);
845
846 test_results(recv_bufs);
847 test_send_ranks(send_bufs);
848 test_recv_ranks(recv_bufs);
849
850 exchanger.clear_send_bufs();
851 exchanger.clear_recv_bufs();
852 }
853 }
854
855
856 TEST_F(NeighborParallelCommTesterDouble, ClassBlocking)
857 {
858 DataExchangeBlocking exchanger(comm);
859 for (int i=0; i < 100; ++i) {
860 set_offset(i);
861
862 if (i % 2 == 0) {
863 exchanger.execute(get_send_lists(), get_receive_lists());
864 } else {
865 exchanger.execute(get_send_lists(), get_receive_lists(), get_num_recvs());
866
867 }
868 test_results(get_receive_lists());
869 test_send_ranks(get_send_lists());
870 test_recv_ranks(get_receive_lists());
871 }
872 }
873
874
875 TEST_F(DenseParallelCommTesterInt, ClassNonBlocking)
876 {
877 DataExchangeNonBlocking exchanger1(comm);
878 DataExchangeNonBlocking exchanger2(comm);
879
880 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
881 EXPECT_FALSE(exchanger1.are_sends_in_progress());
882 EXPECT_FALSE(exchanger2.are_recvs_in_progress());
883 EXPECT_FALSE(exchanger2.are_sends_in_progress());
884
885 auto& sendListsTest = get_send_lists();
886 auto& recvListsTest = get_receive_lists();
887
888 for (int i=0; i < 100; ++i) {
889 set_offset(i);
890 std::vector< std::vector<ElementType> > sendLists2 = sendListsTest;
891 std::vector< std::vector<ElementType> > recvLists2 = recvListsTest;
892
893 exchanger1.start_nonblocking(sendListsTest, recvLists);
894 exchanger2.start_nonblocking(sendLists2, recvLists2);
895
896 EXPECT_TRUE(exchanger1.are_recvs_in_progress());
897 EXPECT_TRUE(exchanger1.are_sends_in_progress());
898 EXPECT_TRUE(exchanger2.are_recvs_in_progress());
899 EXPECT_TRUE(exchanger2.are_sends_in_progress());
900 exchanger1.post_nonblocking_receives(recvListsTest);
901 exchanger2.post_nonblocking_receives(recvLists2);
902 test_send_ranks(sendListsTest);
903 test_recv_ranks(recvListsTest);
904
905 test_send_ranks(sendLists2);
906 test_recv_ranks(recvLists2);
907
908 auto f = [&](int rank, std::vector<int>& buf) { test_recv_vals(buf, rank); };
909
910 exchanger1.complete_receives(recvLists, f);
911 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
912 EXPECT_TRUE(exchanger1.are_sends_in_progress());
913 test_results(recvLists);
914
915 exchanger2.complete_receives(recvLists2, f);
916 EXPECT_FALSE(exchanger2.are_recvs_in_progress());
917 EXPECT_TRUE(exchanger2.are_sends_in_progress());
918 test_results(recvLists2);
919
920 exchanger1.complete_sends();
921 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
922 EXPECT_FALSE(exchanger1.are_sends_in_progress());
923
924 exchanger2.complete_sends();
925 EXPECT_FALSE(exchanger2.are_sends_in_progress());
926 EXPECT_FALSE(exchanger2.are_recvs_in_progress());
927 }
928 }
929
930 TEST_F(DenseParallelCommTesterInt, ClassNonBlockingKnownPattern)
931 {
932 DataExchangeNonBlockingKnown exchanger1(comm);
933 DataExchangeNonBlockingKnown exchanger2(comm);
934
935 auto& sendListsTest = get_send_lists();
936 auto& recvListsTest = get_receive_lists();
937 set_recv_buffer_sizes(recvLists);
938
939 for (int i=0; i < 100; ++i) {
940 set_offset(i);
941 std::vector< std::vector<ElementType> > sendLists2 = sendListsTest;
942 std::vector< std::vector<ElementType> > recvLists2 = recvListsTest;
943
944 exchanger1.start_nonblocking(sendListsTest, recvLists);
945 exchanger2.start_nonblocking(sendLists2, recvLists2);
946
947 auto f = [&](int rank, std::vector<int>& buf) { test_recv_vals(buf, rank); };
948
949 exchanger1.complete_receives(recvListsTest, f);
950 test_results(recvListsTest);
951
952 exchanger2.complete_receives(recvLists2, f);
953 test_results(recvLists2);
954
955 exchanger1.complete_sends();
956 exchanger2.complete_sends();
957 }
958 }
959
960 TEST_F(DenseParallelCommTesterInt, ClassNonBlockingUserDataKnownPattern)
961 {
962 DataExchangeNonBlockingPtr exchanger(comm);
963
964 for (int i=0; i < 1; ++i)
965 {
966 set_offset(i);
967 std::vector<int> allSendBufs, allRecvBufs;
968 std::vector<stk::PointerAndSize> sendBufPointers, recvBufPointers;
969 std::vector<int> sendRanks, recvRanks;
970
971 size_t totalSendSize = 0;
972 size_t totalRecvSize = 0;
973 for (int rank=0; rank < commSize; ++rank)
974 {
975 totalSendSize += get_size(myrank, rank);
976 totalRecvSize += get_size(rank, myrank);
977 }
978
979 allSendBufs.reserve(totalSendSize);
980 allRecvBufs.resize(totalRecvSize);
981
982 size_t valuesSent = 0;
983 size_t valuesReceived = 0;
984 for (int rank=0; rank < commSize; ++rank)
985 {
986 int sendCount = get_size(myrank, rank);
987 int recvCount = get_size(rank, myrank);
988
989 for (int j=0; j < sendCount; ++j)
990 {
991 allSendBufs.push_back(get_value(myrank, rank, j));
992 }
993 auto sendBufBegin = reinterpret_cast<unsigned char*>(allSendBufs.data() + valuesSent);
994 sendBufPointers.emplace_back(sendBufBegin, sendCount * sizeof(int));
995 sendRanks.push_back(rank);
996 valuesSent += sendCount;
997
998 auto recvBufBegin = reinterpret_cast<unsigned char*>(allRecvBufs.data() + valuesReceived);
999 recvRanks.push_back(rank);
1000 recvBufPointers.emplace_back(recvBufBegin, recvCount * sizeof (int));
1001 valuesReceived += recvCount;
1002 }
1003
1004 exchanger.start_nonblocking(sendBufPointers, sendRanks,
1005 recvBufPointers, recvRanks);
1006
1007 std::vector<bool> senderRankSeen(commSize, false);
1008 auto unpacker = [&](int senderRank, const stk::PointerAndSize& buf)
1009 {
1010 size_t offset = 0;
1011 for (int rank=0; rank < senderRank; ++rank)
1012 {
1013 offset += get_size(rank, myrank);
1014 }
1015
1016 int recvCount = get_size(senderRank, myrank);
1017 const int* ptr = reinterpret_cast<const int*>(buf.ptr);
1018 EXPECT_EQ(buf.size, recvCount * sizeof(int));
1019 EXPECT_EQ(ptr, allRecvBufs.data() + offset);
1020
1021 for (int k=0; k < recvCount; ++k)
1022 {
1023 int expectedValue = get_value(senderRank, myrank, k);
1024 EXPECT_EQ(ptr[k], expectedValue);
1025 EXPECT_EQ(allRecvBufs[k + offset], expectedValue);
1026 }
1027 senderRankSeen[senderRank] = true;
1028 };
1029
1030 exchanger.complete_receives(recvBufPointers, recvRanks, unpacker);
1031 for (bool val : senderRankSeen)
1032 {
1033 EXPECT_TRUE(val);
1034 }
1035
1036 exchanger.complete_sends();
1037 }
1038 }
1039
1040 TEST_F(DenseParallelCommTesterInt, ClassNonBlockingBufferKnownPattern)
1041 {
1042 DataExchangeNonBlockingBufferKnown<int> exchanger1(comm);
1043 DataExchangeNonBlockingBufferKnown<int> exchanger2(comm);
1044
1045 auto& sendListsTest = get_send_lists();
1046 auto& recvListsTest = get_receive_lists();
1047 set_recv_buffer_sizes(recvLists);
1048
1049 for (int i=0; i < 100; ++i) {
1050 set_offset(i);
1051 //std::vector< std::vector<ElementType> > sendLists2 = sendLists;
1052 //std::vector< std::vector<ElementType> > recvLists2 = recvLists;
1053
1054 for (int rank=0; rank < commSize; ++rank) {
1055 exchanger1.get_send_buf(rank).assign(sendListsTest[rank].begin(), sendListsTest[rank].end());
1056 exchanger2.get_send_buf(rank).assign(sendListsTest[rank].begin(), sendListsTest[rank].end());
1057 exchanger1.get_recv_buf(rank).resize(recvListsTest[rank].size());
1058 exchanger2.get_recv_buf(rank).resize(recvListsTest[rank].size());
1059 }
1060
1061 exchanger1.start_nonblocking();
1062 exchanger2.start_nonblocking();
1063
1064 auto f = [&](int rank, std::vector<int>& buf) { test_recv_vals(buf, rank); };
1065
1066 exchanger1.complete_receives(f);
1067 exchanger1.clear_recv_bufs();
1068
1069 exchanger2.complete_receives(f);
1070 exchanger2.clear_recv_bufs();
1071
1072 exchanger1.complete_sends();
1073 exchanger2.complete_sends();
1074
1075 exchanger1.clear_send_bufs();
1076 exchanger2.clear_recv_bufs();
1077 }
1078 }
1079
1080 TEST_F(DenseParallelCommTesterInt, ClassNonBlockingCommBufferKnownPattern)
1081 {
1082 DataExchangeNonBlockingCommBufferKnown exchanger1(comm);
1083 DataExchangeNonBlockingCommBufferKnown exchanger2(comm);
1084
1085 auto& sendListsTest = get_send_lists();
1086 auto& recvListsTest = get_receive_lists();
1087 set_recv_buffer_sizes(recvLists);
1088
1089 for (int i=0; i < 100; ++i) {
1090 set_offset(i);
1091 //std::vector< std::vector<ElementType> > sendLists2 = sendLists;
1092 //std::vector< std::vector<ElementType> > recvLists2 = recvLists;
1093
1094 for (int phase=0; phase < 2; ++phase)
1095 {
1096 for (int rank=0; rank < commSize; ++rank) {
1097 for (auto& val : sendListsTest[rank]) {
1098 exchanger1.get_send_buf(rank).pack(val);
1099 exchanger2.get_send_buf(rank).pack(val);
1100 }
1101
1102 exchanger1.set_recv_buffer_size(rank, sizeof(int)*recvListsTest[rank].size());
1103 exchanger2.set_recv_buffer_size(rank, sizeof(int)*recvListsTest[rank].size());
1104 }
1105
1106 if (phase == 0)
1107 {
1108 exchanger1.allocate_send_buffers();
1109 exchanger2.allocate_send_buffers();
1110 }
1111 }
1112
1113 exchanger1.allocate_recv_buffers();
1114 exchanger2.allocate_recv_buffers();
1115
1116 exchanger1.start_nonblocking();
1117 exchanger2.start_nonblocking();
1118
1119 auto f = [&](int /*rank*/, stk::CommBuffer& /*buf*/) {};
1120
1121 exchanger1.complete_receives(f);
1122 auto recvListsCopy = copy_recv_bufs<int>(exchanger1);
1123 test_results(recvListsCopy);
1124 exchanger1.clear_recv_bufs();
1125
1126 exchanger2.complete_receives(f);
1127 recvListsCopy = copy_recv_bufs<int>(exchanger2);
1128 test_results(recvListsCopy);
1129 exchanger2.clear_recv_bufs();
1130
1131 exchanger1.complete_sends();
1132 exchanger2.complete_sends();
1133
1134 exchanger1.clear_send_bufs();
1135 exchanger2.clear_send_bufs();
1136 }
1137 }
1138
1139
1140 TEST_F(DenseParallelCommTesterDouble, ClassNonBlocking)
1141 {
1142 DataExchangeNonBlocking exchanger1(comm);
1143 DataExchangeNonBlocking exchanger2(comm);
1144
1145 auto& sendListsTest = get_send_lists();
1146 auto& recvListsTest = get_receive_lists();
1147
1148 for (int i=0; i < 100; ++i) {
1149 set_offset(i);
1150 std::vector< std::vector<ElementType> > sendLists2 = sendListsTest;
1151 std::vector< std::vector<ElementType> > recvLists2 = recvListsTest;
1152
1153 exchanger1.start_nonblocking(sendListsTest, recvListsTest);
1154 exchanger2.start_nonblocking(sendLists2, recvLists2);
1155 exchanger1.post_nonblocking_receives(recvListsTest);
1156 exchanger2.post_nonblocking_receives(recvLists2);
1157 test_send_ranks(sendListsTest);
1158 test_recv_ranks(recvListsTest);
1159
1160 test_send_ranks(sendLists2);
1161 test_recv_ranks(recvLists2);
1162
1163 auto f = [&](int rank, std::vector<double>& buf) { test_recv_vals(buf, rank); };
1164
1165 exchanger1.complete_receives(recvLists, f);
1166 test_results(recvLists);
1167
1168 exchanger2.complete_receives(recvLists2, f);
1169 test_results(recvLists2);
1170
1171 exchanger1.complete_sends();
1172 exchanger2.complete_sends();
1173 }
1174 }
1175
1176
1177 TEST_F(DenseParallelCommTesterInt, ClassNonBlockingBuffer)
1178 {
1179 DataExchangeNonBlockingBuffer<int> exchanger1(comm);
1180
1181 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1182 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1183
1184 for (int i=0; i < 100; ++i) {
1185 set_offset(i);
1186
1187 for (int j=0; j < commSize; ++j)
1188 {
1189 auto& send_buf = exchanger1.get_send_buf(j);
1190 send_buf.assign(get_send_lists()[j].begin(), get_send_lists()[j].end());
1191 }
1192
1193 if (i % 2 == 0) {
1194 exchanger1.start_nonblocking();
1195 } else {
1196 exchanger1.start_nonblocking(get_num_recvs());
1197 }
1198
1199 EXPECT_TRUE(exchanger1.are_recvs_in_progress());
1200 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1201 EXPECT_ANY_THROW(exchanger1.get_send_buf(0));
1202 EXPECT_ANY_THROW(exchanger1.get_recv_buf(0));
1203
1204 exchanger1.post_nonblocking_receives();
1205
1206 auto f = [](int , std::vector<int>&) {};
1207
1208 exchanger1.complete_receives(f);
1209 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1210 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1211 EXPECT_ANY_THROW(exchanger1.get_send_buf(0));
1212 std::vector< std::vector<int> >recvListsTest = copy_recv_bufs(exchanger1);
1213 test_recv_ranks(recvListsTest);
1214 test_results(recvListsTest);
1215
1216 exchanger1.complete_sends();
1217 std::vector< std::vector<int> > sendListsTest = copy_send_bufs(exchanger1);
1218 test_send_ranks(sendListsTest);
1219
1220 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1221 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1222 }
1223 }
1224
1225 TEST_F(DenseParallelCommTesterInt, ClassNonBlockingCommBuffer)
1226 {
1227 DataExchangeNonBlockingCommBuffer exchanger1(comm);
1228
1229 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1230 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1231
1232 for (int i=0; i < 100; ++i) {
1233 set_offset(i);
1234
1235 for (int phase=0; phase < 2; ++phase) {
1236 for (int j=0; j < commSize; ++j) {
1237 auto& send_buf = exchanger1.get_send_buf(j);
1238 for (auto& val : get_send_lists()[j]) {
1239 send_buf.pack(val);
1240 }
1241 }
1242 if (phase == 0) {
1243 exchanger1.allocate_send_buffers();
1244 }
1245 }
1246
1247 if (i % 2 == 0) {
1248 exchanger1.start_nonblocking();
1249 } else {
1250 exchanger1.start_nonblocking(get_num_recvs());
1251 }
1252
1253 EXPECT_TRUE(exchanger1.are_recvs_in_progress());
1254 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1255 EXPECT_ANY_THROW(exchanger1.get_send_buf(0));
1256 EXPECT_ANY_THROW(exchanger1.get_recv_buf(0));
1257
1258 exchanger1.post_nonblocking_receives();
1259
1260 auto f = [](int , stk::CommBuffer&) {};
1261
1262 exchanger1.complete_receives(f);
1263 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1264 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1265 EXPECT_ANY_THROW(exchanger1.get_send_buf(0));
1266 recvLists = copy_recv_bufs<int>(exchanger1);
1267 test_recv_ranks(recvLists);
1268 test_results(recvLists);
1269
1270 exchanger1.complete_sends();
1271 std::vector< std::vector<int> > sendListsTest = copy_send_bufs<int>(exchanger1);
1272 test_send_ranks(sendListsTest);
1273
1274 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1275 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1276 exchanger1.clear_send_bufs();
1277 exchanger1.clear_recv_bufs();
1278 }
1279 }
1280
1281 TEST_F(DenseParallelCommTesterDouble, ClassNonBlockingKnownPattern)
1282 {
1283 DataExchangeNonBlockingKnown exchanger1(comm);
1284 DataExchangeNonBlockingKnown exchanger2(comm);
1285
1286 auto& sendListsTest = get_send_lists();
1287 auto& recvListsTest = get_receive_lists();
1288 set_recv_buffer_sizes(recvLists);
1289
1290 for (int i=0; i < 100; ++i) {
1291 set_offset(i);
1292 std::vector< std::vector<ElementType> > sendLists2 = sendListsTest;
1293 std::vector< std::vector<ElementType> > recvLists2 = recvListsTest;
1294
1295 exchanger1.start_nonblocking(sendListsTest, recvListsTest);
1296 exchanger2.start_nonblocking(sendLists2, recvLists2);
1297
1298 auto f = [&](int rank, std::vector<double>& buf) { test_recv_vals(buf, rank); };
1299
1300 exchanger1.complete_receives(recvListsTest, f);
1301 test_results(recvListsTest);
1302
1303 exchanger2.complete_receives(recvLists2, f);
1304 test_results(recvLists2);
1305
1306 exchanger1.complete_sends();
1307 exchanger2.complete_sends();
1308 }
1309 }
1310
1311 TEST_F(DenseParallelCommTesterDouble, ClassNonBlockingUserDataKnownPattern)
1312 {
1313 DataExchangeNonBlockingPtr exchanger(comm);
1314
1315 for (int i=0; i < 1; ++i)
1316 {
1317 set_offset(i);
1318 std::vector<double> allSendBufs, allRecvBufs;
1319 std::vector<stk::PointerAndSize> sendBufPointers, recvBufPointers;
1320 std::vector<int> sendRanks, recvRanks;
1321
1322 size_t totalSendSize = 0;
1323 size_t totalRecvSize = 0;
1324 for (int rank=0; rank < commSize; ++rank)
1325 {
1326 totalSendSize += get_size(myrank, rank);
1327 totalRecvSize += get_size(rank, myrank);
1328 }
1329
1330 allSendBufs.reserve(totalSendSize);
1331 allRecvBufs.resize(totalRecvSize);
1332
1333 size_t valuesSent = 0;
1334 size_t valuesReceived = 0;
1335 for (int rank=0; rank < commSize; ++rank)
1336 {
1337 int sendCount = get_size(myrank, rank);
1338 int recvCount = get_size(rank, myrank);
1339
1340 for (int j=0; j < sendCount; ++j)
1341 {
1342 allSendBufs.push_back(get_value(myrank, rank, j));
1343 }
1344 auto sendBufBegin = reinterpret_cast<unsigned char*>(allSendBufs.data() + valuesSent);
1345 sendBufPointers.emplace_back(sendBufBegin, sendCount * sizeof(double));
1346 sendRanks.push_back(rank);
1347 valuesSent += sendCount;
1348
1349 auto recvBufBegin = reinterpret_cast<unsigned char*>(allRecvBufs.data() + valuesReceived);
1350 recvRanks.push_back(rank);
1351 recvBufPointers.emplace_back(recvBufBegin, recvCount * sizeof(double));
1352 valuesReceived += recvCount;
1353 }
1354
1355 exchanger.start_nonblocking(sendBufPointers, sendRanks,
1356 recvBufPointers, recvRanks);
1357
1358 std::vector<bool> senderRankSeen(commSize, false);
1359 auto unpacker = [&](int senderRank, const stk::PointerAndSize& buf)
1360 {
1361 size_t offset = 0;
1362 for (int rank=0; rank < senderRank; ++rank)
1363 {
1364 offset += get_size(rank, myrank);
1365 }
1366
1367 int recvCount = get_size(senderRank, myrank);
1368 const double* ptr = reinterpret_cast<const double*>(buf.ptr);
1369 EXPECT_EQ(buf.size, recvCount * sizeof(double));
1370 EXPECT_EQ(ptr, allRecvBufs.data() + offset);
1371
1372 for (int k=0; k < recvCount; ++k)
1373 {
1374 int expectedValue = get_value(senderRank, myrank, k);
1375 EXPECT_EQ(ptr[k], expectedValue);
1376 EXPECT_EQ(allRecvBufs[k + offset], expectedValue);
1377 }
1378 senderRankSeen[senderRank] = true;
1379 };
1380
1381 exchanger.complete_receives(recvBufPointers, recvRanks, unpacker);
1382 for (bool val : senderRankSeen)
1383 {
1384 EXPECT_TRUE(val);
1385 }
1386
1387 exchanger.complete_sends();
1388 }
1389 }
1390
1391
1392 TEST_F(DenseParallelCommTesterDouble, ClassNonBlockingBufferKnownPattern)
1393 {
1394 DataExchangeNonBlockingBufferKnown<double> exchanger1(comm);
1395 DataExchangeNonBlockingBufferKnown<double> exchanger2(comm);
1396
1397 auto& sendListsTest = get_send_lists();
1398 auto& recvListsTest = get_receive_lists();
1399 set_recv_buffer_sizes(recvLists);
1400
1401 for (int i=0; i < 100; ++i) {
1402 set_offset(i);
1403 //std::vector< std::vector<ElementType> > sendLists2 = sendLists;
1404 //std::vector< std::vector<ElementType> > recvLists2 = recvLists;
1405
1406 for (int rank=0; rank < commSize; ++rank) {
1407 exchanger1.get_send_buf(rank).assign(sendListsTest[rank].begin(), sendListsTest[rank].end());
1408 exchanger2.get_send_buf(rank).assign(sendListsTest[rank].begin(), sendListsTest[rank].end());
1409 exchanger1.get_recv_buf(rank).resize(recvListsTest[rank].size());
1410 exchanger2.get_recv_buf(rank).resize(recvListsTest[rank].size());
1411 }
1412
1413 exchanger1.start_nonblocking();
1414 exchanger2.start_nonblocking();
1415
1416 auto f = [&](int rank, std::vector<double>& buf) { test_recv_vals(buf, rank); };
1417
1418 exchanger1.complete_receives(f);
1419 exchanger1.clear_recv_bufs();
1420
1421 exchanger2.complete_receives(f);
1422 exchanger2.clear_recv_bufs();
1423
1424 exchanger1.complete_sends();
1425 exchanger2.complete_sends();
1426
1427 exchanger1.clear_send_bufs();
1428 exchanger2.clear_recv_bufs();
1429 }
1430 }
1431
1432 TEST_F(DenseParallelCommTesterDouble, ClassNonBlockingCommBufferKnownPattern)
1433 {
1434 DataExchangeNonBlockingCommBufferKnown exchanger1(comm);
1435 DataExchangeNonBlockingCommBufferKnown exchanger2(comm);
1436
1437 auto& sendListsTest = get_send_lists();
1438 auto& recvListsTest = get_receive_lists();
1439 set_recv_buffer_sizes(recvLists);
1440
1441 for (int i=0; i < 100; ++i) {
1442 set_offset(i);
1443 //std::vector< std::vector<ElementType> > sendLists2 = sendLists;
1444 //std::vector< std::vector<ElementType> > recvLists2 = recvLists;
1445
1446 for (int phase=0; phase < 2; ++phase)
1447 {
1448 for (int rank=0; rank < commSize; ++rank) {
1449 for (auto& val : sendListsTest[rank]) {
1450 exchanger1.get_send_buf(rank).pack(val);
1451 exchanger2.get_send_buf(rank).pack(val);
1452 }
1453
1454 exchanger1.set_recv_buffer_size(rank, sizeof(double)*recvListsTest[rank].size());
1455 exchanger2.set_recv_buffer_size(rank, sizeof(double)*recvListsTest[rank].size());
1456 }
1457
1458 if (phase == 0)
1459 {
1460 exchanger1.allocate_send_buffers();
1461 exchanger2.allocate_send_buffers();
1462 }
1463 }
1464
1465 exchanger1.allocate_recv_buffers();
1466 exchanger2.allocate_recv_buffers();
1467
1468 exchanger1.start_nonblocking();
1469 exchanger2.start_nonblocking();
1470
1471 auto f = [&](int , stk::CommBuffer& ) {};
1472
1473 exchanger1.complete_receives(f);
1474 auto recvListsCopy = copy_recv_bufs<double>(exchanger1);
1475 test_results(recvListsCopy);
1476 exchanger1.clear_recv_bufs();
1477
1478 exchanger2.complete_receives(f);
1479 recvListsCopy = copy_recv_bufs<double>(exchanger2);
1480 test_results(recvListsCopy);
1481 exchanger2.clear_recv_bufs();
1482
1483 exchanger1.complete_sends();
1484 exchanger2.complete_sends();
1485
1486 exchanger1.clear_send_bufs();
1487 exchanger2.clear_send_bufs();
1488 }
1489 }
1490
1491 TEST_F(NeighborParallelCommTesterInt, ClassNonBlocking)
1492 {
1493 DataExchangeNonBlocking exchanger1(comm);
1494
1495 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1496 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1497
1498 auto& sendListsTest = get_send_lists();
1499 auto& recvListsTest = get_receive_lists();
1500
1501 for (int i=0; i < 100; ++i) {
1502 set_offset(i);
1503
1504 if (i % 2 == 0) {
1505 exchanger1.start_nonblocking(sendListsTest, recvListsTest);
1506 } else {
1507 exchanger1.start_nonblocking(sendListsTest, recvListsTest, get_num_recvs());
1508 }
1509
1510 EXPECT_TRUE(exchanger1.are_recvs_in_progress());
1511 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1512 exchanger1.post_nonblocking_receives(recvListsTest);
1513 test_send_ranks(sendListsTest);
1514 test_recv_ranks(recvListsTest);
1515
1516 auto f = [&](int rank, std::vector<int>& buf) { test_recv_vals(buf, rank); };
1517
1518 exchanger1.complete_receives(recvListsTest, f);
1519 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1520 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1521 test_results(recvListsTest);
1522
1523 exchanger1.complete_sends();
1524 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1525 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1526 }
1527 }
1528
1529 TEST_F(NeighborParallelCommTesterInt, ClassNonBlockingKnownPattern)
1530 {
1531 DataExchangeNonBlockingKnown exchanger1(comm);
1532 DataExchangeNonBlockingKnown exchanger2(comm);
1533
1534 auto& sendListsTest = get_send_lists();
1535 auto& recvListsTest = get_receive_lists();
1536 set_recv_buffer_sizes(recvLists);
1537
1538 for (int i=0; i < 100; ++i) {
1539 set_offset(i);
1540 std::vector< std::vector<ElementType> > sendLists2 = sendListsTest;
1541 std::vector< std::vector<ElementType> > recvLists2 = recvListsTest;
1542
1543 exchanger1.start_nonblocking(sendListsTest, recvListsTest);
1544 exchanger2.start_nonblocking(sendLists2, recvLists2);
1545
1546 auto f = [&](int rank, std::vector<int>& buf) { test_recv_vals(buf, rank); };
1547
1548 exchanger1.complete_receives(recvListsTest, f);
1549 test_results(recvListsTest);
1550
1551 exchanger2.complete_receives(recvLists2, f);
1552 test_results(recvLists2);
1553
1554 exchanger1.complete_sends();
1555 exchanger2.complete_sends();
1556 }
1557 }
1558
1559 TEST_F(NeighborParallelCommTesterInt, ClassNonBlockingUserDataKnownPattern)
1560 {
1561 DataExchangeNonBlockingPtr exchanger(comm);
1562
1563 for (int i=0; i < 1; ++i)
1564 {
1565 set_offset(i);
1566 std::vector<int> allSendBufs, allRecvBufs;
1567 std::vector<stk::PointerAndSize> sendBufPointers, recvBufPointers;
1568 std::vector<int> sendRanks = get_dest_ranks();
1569 std::vector<int> recvRanks = get_src_ranks();
1570
1571 size_t totalSendSize = 0;
1572 size_t totalRecvSize = 0;
1573 for (int rank : sendRanks)
1574 {
1575 totalSendSize += get_size(myrank, rank);
1576 }
1577
1578 for (int rank : recvRanks)
1579 {
1580 totalRecvSize += get_size(rank, myrank);
1581 }
1582
1583 allSendBufs.reserve(totalSendSize);
1584 allRecvBufs.resize(totalRecvSize);
1585
1586 size_t valuesSent = 0;
1587 size_t valuesReceived = 0;
1588 for (int rank : sendRanks)
1589 {
1590 int sendCount = get_size(myrank, rank);
1591 for (int j=0; j < sendCount; ++j)
1592 {
1593 allSendBufs.push_back(get_value(myrank, rank, j));
1594 }
1595 auto sendBufBegin = reinterpret_cast<unsigned char*>(allSendBufs.data() + valuesSent);
1596 sendBufPointers.emplace_back(sendBufBegin, sendCount * sizeof(int));
1597 valuesSent += sendCount;
1598 }
1599
1600 for (int rank : recvRanks)
1601 {
1602 int recvCount = get_size(rank, myrank);
1603 auto recvBufBegin = reinterpret_cast<unsigned char*>(allRecvBufs.data() + valuesReceived);
1604 recvBufPointers.emplace_back(recvBufBegin, recvCount * sizeof (int));
1605 valuesReceived += recvCount;
1606 }
1607
1608 exchanger.start_nonblocking(sendBufPointers, sendRanks,
1609 recvBufPointers, recvRanks);
1610
1611 auto unpacker = [&](int senderRank, const stk::PointerAndSize& buf)
1612 {
1613 size_t offset = 0;
1614 auto senderRankIt = std::find(recvRanks.begin(), recvRanks.end(), senderRank);
1615 EXPECT_NE(senderRankIt, recvRanks.end());
1616 for (auto it = recvRanks.begin(); it != senderRankIt; ++it)
1617 {
1618 offset += get_size(*it, myrank);
1619 }
1620
1621 int recvCount = get_size(senderRank, myrank);
1622 const int* ptr = reinterpret_cast<const int*>(buf.ptr);
1623 EXPECT_EQ(buf.size, recvCount * sizeof(int));
1624 EXPECT_EQ(ptr, allRecvBufs.data() + offset);
1625
1626 for (int k=0; k < recvCount; ++k)
1627 {
1628 int expectedValue = get_value(senderRank, myrank, k);
1629 EXPECT_EQ(ptr[k], expectedValue);
1630 EXPECT_EQ(allRecvBufs[k + offset], expectedValue);
1631 }
1632 };
1633
1634 exchanger.complete_receives(recvBufPointers, recvRanks, unpacker);
1635 exchanger.complete_sends();
1636 }
1637 }
1638
1639 TEST_F(NeighborParallelCommTesterInt, ClassNonBlockingBufferKnownPattern)
1640 {
1641 DataExchangeNonBlockingBufferKnown<int> exchanger1(comm);
1642 DataExchangeNonBlockingBufferKnown<int> exchanger2(comm);
1643
1644 auto& sendListsTest = get_send_lists();
1645 auto& recvListsTest = get_receive_lists();
1646 set_recv_buffer_sizes(recvListsTest);
1647
1648 for (int i=0; i < 100; ++i) {
1649 set_offset(i);
1650 //std::vector< std::vector<ElementType> > sendLists2 = sendLists;
1651 //std::vector< std::vector<ElementType> > recvLists2 = recvLists;
1652
1653 for (int rank=0; rank < commSize; ++rank) {
1654 exchanger1.get_send_buf(rank).assign(sendListsTest[rank].begin(), sendListsTest[rank].end());
1655 exchanger2.get_send_buf(rank).assign(sendListsTest[rank].begin(), sendListsTest[rank].end());
1656 exchanger1.get_recv_buf(rank).resize(recvListsTest[rank].size());
1657 exchanger2.get_recv_buf(rank).resize(recvListsTest[rank].size());
1658 }
1659
1660 exchanger1.start_nonblocking();
1661 exchanger2.start_nonblocking();
1662
1663 auto f = [&](int rank, std::vector<int>& buf) { test_recv_vals(buf, rank); };
1664
1665 exchanger1.complete_receives(f);
1666 exchanger1.clear_recv_bufs();
1667
1668 exchanger2.complete_receives(f);
1669 exchanger2.clear_recv_bufs();
1670
1671 exchanger1.complete_sends();
1672 exchanger2.complete_sends();
1673
1674 exchanger1.clear_send_bufs();
1675 exchanger2.clear_recv_bufs();
1676 }
1677 }
1678
1679 TEST_F(NeighborParallelCommTesterInt, ClassNonBlockingCommBufferKnownPattern)
1680 {
1681 DataExchangeNonBlockingCommBufferKnown exchanger1(comm);
1682 DataExchangeNonBlockingCommBufferKnown exchanger2(comm);
1683
1684 auto& sendListsTest = get_send_lists();
1685 auto& recvListsTest = get_receive_lists();
1686 set_recv_buffer_sizes(recvListsTest);
1687
1688 for (int i=0; i < 100; ++i) {
1689 set_offset(i);
1690 //std::vector< std::vector<ElementType> > sendLists2 = sendLists;
1691 //std::vector< std::vector<ElementType> > recvLists2 = recvLists;
1692
1693 for (int phase=0; phase < 2; ++phase)
1694 {
1695 for (int rank=0; rank < commSize; ++rank) {
1696 for (auto& val : sendListsTest[rank]) {
1697 exchanger1.get_send_buf(rank).pack(val);
1698 exchanger2.get_send_buf(rank).pack(val);
1699 }
1700
1701 exchanger1.set_recv_buffer_size(rank, sizeof(int)*recvListsTest[rank].size());
1702 exchanger2.set_recv_buffer_size(rank, sizeof(int)*recvListsTest[rank].size());
1703 }
1704
1705 if (phase == 0)
1706 {
1707 exchanger1.allocate_send_buffers();
1708 exchanger2.allocate_send_buffers();
1709 }
1710 }
1711
1712 exchanger1.allocate_recv_buffers();
1713 exchanger2.allocate_recv_buffers();
1714
1715 exchanger1.start_nonblocking();
1716 exchanger2.start_nonblocking();
1717
1718 auto f = [&](int , stk::CommBuffer& ) {};
1719
1720 exchanger1.complete_receives(f);
1721 auto recvListsCopy = copy_recv_bufs<int>(exchanger1);
1722 test_results(recvListsCopy);
1723 exchanger1.clear_recv_bufs();
1724
1725 exchanger2.complete_receives(f);
1726 recvListsCopy = copy_recv_bufs<int>(exchanger2);
1727 test_results(recvListsCopy);
1728 exchanger2.clear_recv_bufs();
1729
1730 exchanger1.complete_sends();
1731 exchanger2.complete_sends();
1732
1733 exchanger1.clear_send_bufs();
1734 exchanger2.clear_send_bufs();
1735 }
1736 }
1737
1738 TEST_F(NeighborParallelCommTesterInt, ClassNonBlockingBuffer)
1739 {
1740 DataExchangeNonBlockingBuffer<int> exchanger1(comm);
1741
1742 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1743 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1744
1745 for (int i=0; i < 100; ++i) {
1746 set_offset(i);
1747
1748 for (int j=0; j < commSize; ++j)
1749 {
1750 auto& send_buf = exchanger1.get_send_buf(j);
1751 send_buf.assign(get_send_lists()[j].begin(), get_send_lists()[j].end());
1752 }
1753
1754 if (i % 2 == 0) {
1755 exchanger1.start_nonblocking();
1756 } else {
1757 exchanger1.start_nonblocking(get_num_recvs());
1758 }
1759
1760 EXPECT_TRUE(exchanger1.are_recvs_in_progress());
1761 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1762
1763 exchanger1.post_nonblocking_receives();
1764
1765 auto f = [](int , std::vector<int>&) {};
1766
1767 exchanger1.complete_receives(f);
1768 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1769 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1770 recvLists = copy_recv_bufs(exchanger1);
1771 test_recv_ranks(recvLists);
1772 test_results(recvLists);
1773
1774 exchanger1.complete_sends();
1775 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1776 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1777 std::vector< std::vector<int> > sendListsTest = copy_send_bufs(exchanger1);
1778 test_send_ranks(sendListsTest);
1779 }
1780 }
1781
1782
1783 TEST_F(NeighborParallelCommTesterInt, ClassNonBlockingCommBuffer)
1784 {
1785 DataExchangeNonBlockingCommBuffer exchanger1(comm);
1786
1787 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1788 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1789
1790 for (int i=0; i < 100; ++i) {
1791 set_offset(i);
1792
1793 for (int phase=0; phase < 2; ++phase) {
1794 for (int j=0; j < commSize; ++j) {
1795 auto& send_buf = exchanger1.get_send_buf(j);
1796 for (auto& val : get_send_lists()[j]) {
1797 send_buf.pack(val);
1798 }
1799 }
1800 if (phase == 0) {
1801 exchanger1.allocate_send_buffers();
1802 }
1803 }
1804
1805 if (i % 2 == 0) {
1806 exchanger1.start_nonblocking();
1807 } else {
1808 exchanger1.start_nonblocking(get_num_recvs());
1809 }
1810 EXPECT_TRUE(exchanger1.are_recvs_in_progress());
1811 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1812 EXPECT_ANY_THROW(exchanger1.get_send_buf(0));
1813 EXPECT_ANY_THROW(exchanger1.get_recv_buf(0));
1814
1815 exchanger1.post_nonblocking_receives();
1816
1817 auto f = [](int , stk::CommBuffer&) {};
1818
1819 exchanger1.complete_receives(f);
1820 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1821 EXPECT_TRUE(exchanger1.are_sends_in_progress());
1822 EXPECT_ANY_THROW(exchanger1.get_send_buf(0));
1823 recvLists = copy_recv_bufs<int>(exchanger1);
1824 test_recv_ranks(recvLists);
1825 test_results(recvLists);
1826
1827 exchanger1.complete_sends();
1828 std::vector< std::vector<int> > sendListsTest = copy_send_bufs<int>(exchanger1);
1829 test_send_ranks(sendListsTest);
1830
1831 EXPECT_FALSE(exchanger1.are_recvs_in_progress());
1832 EXPECT_FALSE(exchanger1.are_sends_in_progress());
1833 exchanger1.clear_send_bufs();
1834 exchanger1.clear_recv_bufs();
1835 }
1836 }
1837
1838
1839 TEST(DenseParallelCommTester, SplitComm)
1840 {
1841 DenseParallelCommTesterBase<int> tester1(false);
1842 DenseParallelCommTesterBase<int> tester2(true);
1843
1844 for (int i=0; i < 100; ++i) {
1845 tester1.set_offset(i);
1846 tester2.set_offset(i);
1847 stk::parallel_data_exchange_t(tester1.get_send_lists(), tester1.get_receive_lists(), tester1.comm);
1848 if (tester2.color == 0) {
1849 stk::parallel_data_exchange_t(tester2.get_send_lists(), tester2.get_receive_lists(), tester2.comm);
1850 }
1851
1852 tester1.test_results(tester1.get_receive_lists());
1853 tester2.test_results(tester2.get_receive_lists());
1854 }
1855 }
1856
1857 namespace {
1858 void send_to_self(stk::DataExchangeKnownPatternNonBlockingCommBuffer& exchanger, int size)
1859 {
1860 using T = int;
1861 int myrank = stk::parallel_machine_rank(MPI_COMM_WORLD);
1862
1863 for (int phase=0; phase < 2; ++phase)
1864 {
1865 for (int i=0; i < size; ++i)
1866 {
1867 exchanger.get_send_buf(myrank).pack<T>(i);
1868 }
1869
1870 if (phase == 0)
1871 exchanger.allocate_send_buffers();
1872 }
1873 exchanger.set_recv_buffer_size(myrank, size * sizeof(T));
1874 exchanger.allocate_recv_buffers();
1875
1876 exchanger.start_nonblocking();
1877
1878 auto unpacker = [&](int rank, stk::CommBuffer& buf)
1879 {
1880 EXPECT_EQ(rank, myrank);
1881 EXPECT_EQ(buf.remaining(), ptrdiff_t(size * sizeof(T)));
1882 for (int i=0; i < size; ++i)
1883 {
1884 T val;
1885 buf.unpack(val);
1886 EXPECT_EQ(val, i);
1887 }
1888 };
1889
1890 exchanger.complete_receives(unpacker);
1891 exchanger.complete_sends();
1892 }
1893 }
1894
1895 TEST(ManagedCommBufferBase, IncreasingSize)
1896 {
1897 stk::DataExchangeKnownPatternNonBlockingCommBuffer exchanger(MPI_COMM_WORLD);
1898 send_to_self(exchanger, 16);
1899
1900 exchanger.clear_send_bufs();
1901 exchanger.clear_recv_bufs();
1902
1903 send_to_self(exchanger, 32);
1904 }
1905
1906 #endif
1907