OpenFPM_pdata  1.1.0
Project that contain the implementation of distributed structures
 All Data Structures Namespaces Functions Variables Typedefs Enumerations Friends Pages
VCluster_semantic_unit_tests.hpp
1 /*
2  * VCluster_semantic_unit_test.hpp
3  *
4  * Created on: Feb 8, 2016
5  * Author: i-bird
6  */
7 
8 #ifndef OPENFPM_VCLUSTER_SRC_VCLUSTER_SEMANTIC_UNIT_TESTS_HPP_
9 #define OPENFPM_VCLUSTER_SRC_VCLUSTER_SEMANTIC_UNIT_TESTS_HPP_
10 
11 #include "Grid/grid_util_test.hpp"
12 #include "data_type/aggregate.hpp"
13 
15 struct Aexample
16 {
18  size_t a;
19 
21  float b;
22 
24  double c;
25 };
26 
27 
28 BOOST_AUTO_TEST_SUITE( VCluster_semantic_test )
29 
30 BOOST_AUTO_TEST_CASE (Vcluster_semantic_gather)
31 {
32  for (size_t i = 0 ; i < 100 ; i++)
33  {
34  Vcluster & vcl = create_vcluster();
35 
36  if (vcl.getProcessUnitID() == 0 && i == 0)
37  std::cout << "Semantic gather test start" << std::endl;
38 
39  if (vcl.getProcessingUnits() >= 32)
40  return;
41 
43 
44  openfpm::vector<size_t> v1;
45  v1.resize(vcl.getProcessUnitID());
46 
47  for(size_t i = 0 ; i < vcl.getProcessUnitID() ; i++)
48  {v1.get(i) = 5;}
49 
50  openfpm::vector<size_t> v2;
51 
52  vcl.SGather(v1,v2,(i%vcl.getProcessingUnits()));
53 
55 
56  if (vcl.getProcessUnitID() == (i%vcl.getProcessingUnits()))
57  {
58  size_t n = vcl.getProcessingUnits();
59  BOOST_REQUIRE_EQUAL(v2.size(),n*(n-1)/2);
60 
61  bool is_five = true;
62  for (size_t i = 0 ; i < v2.size() ; i++)
63  is_five &= (v2.get(i) == 5);
64 
65  BOOST_REQUIRE_EQUAL(is_five,true);
66  }
67  }
68 }
69 
70 BOOST_AUTO_TEST_CASE (Vcluster_semantic_gather_2)
71 {
72  for (size_t i = 0 ; i < 100 ; i++)
73  {
74  Vcluster & vcl = create_vcluster();
75 
76  if (vcl.getProcessingUnits() >= 32)
77  return;
78 
80 
81  openfpm::vector<size_t> v1;
82  v1.resize(vcl.getProcessUnitID());
83 
84  for(size_t i = 0 ; i < vcl.getProcessUnitID() ; i++)
85  {v1.get(i) = 5;}
86 
87  openfpm::vector<openfpm::vector<size_t>> v2;
88 
89  vcl.SGather(v1,v2,0);
90 
92 
93  if (vcl.getProcessUnitID() == 0)
94  {
95  size_t n = vcl.getProcessingUnits();
96  BOOST_REQUIRE_EQUAL(v2.size(),n);
97 
98  bool is_five = true;
99  for (size_t i = 0 ; i < v2.size() ; i++)
100  {
101  for (size_t j = 0 ; j < v2.get(i).size() ; j++)
102  is_five &= (v2.get(i).get(j) == 5);
103  }
104  BOOST_REQUIRE_EQUAL(is_five,true);
105 
106  }
107 
108  openfpm::vector<openfpm::vector<size_t>> v3;
109 
110  vcl.SGather(v1,v3,1);
111 
112  if (vcl.getProcessUnitID() == 1)
113  {
114  size_t n = vcl.getProcessingUnits();
115  BOOST_REQUIRE_EQUAL(v3.size(),n-1);
116 
117  bool is_five = true;
118  for (size_t i = 0 ; i < v3.size() ; i++)
119  {
120  for (size_t j = 0 ; j < v3.get(i).size() ; j++)
121  is_five &= (v3.get(i).get(j) == 5);
122  }
123  BOOST_REQUIRE_EQUAL(is_five,true);
124 
125  }
126  }
127 }
128 
129 BOOST_AUTO_TEST_CASE (Vcluster_semantic_gather_3)
130 {
131  for (size_t i = 0 ; i < 100 ; i++)
132  {
133  Vcluster & vcl = create_vcluster();
134 
135  if (vcl.getProcessingUnits() >= 32)
136  {return;}
137 
138  openfpm::vector<openfpm::vector<aggregate<float, openfpm::vector<size_t>, Point_test<float>>> > v1;
139 
140  openfpm::vector<aggregate<float, openfpm::vector<size_t>, Point_test<float>>> v1_int;
141  aggregate<float, openfpm::vector<size_t>, Point_test<float>> aggr;
142  openfpm::vector<size_t> v1_int2;
143 
144  v1_int2.add((size_t)7);
145  v1_int2.add((size_t)7);
146 
147  aggr.template get<0>() = 7;
148  aggr.template get<1>() = v1_int2;
149  Point_test<float> p;
150  p.fill();
151  aggr.template get<2>() = p;
152 
153  v1_int.add(aggr);
154  v1_int.add(aggr);
155  v1_int.add(aggr);
156 
157  v1.add(v1_int);
158  v1.add(v1_int);
159  v1.add(v1_int);
160  v1.add(v1_int);
161 
162  openfpm::vector<openfpm::vector<aggregate<float, openfpm::vector<size_t>, Point_test<float>>> > v2;
163 
164  vcl.SGather(v1,v2,0);
165 
166  if (vcl.getProcessUnitID() == 0)
167  {
168  size_t n = vcl.getProcessingUnits();
169 
170  BOOST_REQUIRE_EQUAL(v2.size(),v1.size()*n);
171 
172  bool is_seven = true;
173  for (size_t i = 0 ; i < v2.size() ; i++)
174  {
175  for (size_t j = 0 ; j < v2.get(i).size() ; j++)
176  {
177  is_seven &= (v2.get(i).template get<0>(j) == 7);
178 
179  for (size_t k = 0; k < v2.get(i).template get<1>(j).size(); k++)
180  is_seven &= (v2.get(i).template get<1>(j).get(k) == 7);
181 
182  Point_test<float> p = v2.get(i).template get<2>(j);
183 
184  BOOST_REQUIRE(p.template get<0>() == 1);
185  BOOST_REQUIRE(p.template get<1>() == 2);
186  BOOST_REQUIRE(p.template get<2>() == 3);
187  BOOST_REQUIRE(p.template get<3>() == 4);
188 
189  for (size_t l = 0 ; l < 3 ; l++)
190  p.template get<4>()[l] = 5;
191 
192  for (size_t m = 0 ; m < 3 ; m++)
193  {
194  for (size_t n = 0 ; n < 3 ; n++)
195  {
196  p.template get<5>()[m][n] = 6;
197  }
198  }
199  }
200  }
201  BOOST_REQUIRE_EQUAL(is_seven,true);
202  }
203  }
204 }
205 
206 BOOST_AUTO_TEST_CASE (Vcluster_semantic_gather_4)
207 {
208  for (size_t i = 0 ; i < 100 ; i++)
209  {
210  Vcluster & vcl = create_vcluster();
211 
212  if (vcl.getProcessingUnits() >= 32)
213  {return;}
214 
215  size_t sz[] = {16,16};
216 
217  grid_cpu<2,Point_test<float>> g1(sz);
218  g1.setMemory();
219  fill_grid<2>(g1);
220 
221  openfpm::vector<grid_cpu<2,Point_test<float>>> v2;
222 
223  vcl.SGather(g1,v2,0);
224 
225  typedef Point_test<float> p;
226 
227  if (vcl.getProcessUnitID() == 0)
228  {
229  size_t n = vcl.getProcessingUnits();
230  BOOST_REQUIRE_EQUAL(v2.size(),n);
231 
232  bool match = true;
233  for (size_t i = 0 ; i < v2.size() ; i++)
234  {
235  auto it = v2.get(i).getIterator();
236 
237  while (it.isNext())
238  {
239  grid_key_dx<2> key = it.get();
240 
241  match &= (v2.get(i).template get<p::x>(key) == g1.template get<p::x>(key));
242  match &= (v2.get(i).template get<p::y>(key) == g1.template get<p::y>(key));
243  match &= (v2.get(i).template get<p::z>(key) == g1.template get<p::z>(key));
244  match &= (v2.get(i).template get<p::s>(key) == g1.template get<p::s>(key));
245 
246  match &= (v2.get(i).template get<p::v>(key)[0] == g1.template get<p::v>(key)[0]);
247  match &= (v2.get(i).template get<p::v>(key)[1] == g1.template get<p::v>(key)[1]);
248  match &= (v2.get(i).template get<p::v>(key)[2] == g1.template get<p::v>(key)[2]);
249 
250  match &= (v2.get(i).template get<p::t>(key)[0][0] == g1.template get<p::t>(key)[0][0]);
251  match &= (v2.get(i).template get<p::t>(key)[0][1] == g1.template get<p::t>(key)[0][1]);
252  match &= (v2.get(i).template get<p::t>(key)[0][2] == g1.template get<p::t>(key)[0][2]);
253  match &= (v2.get(i).template get<p::t>(key)[1][0] == g1.template get<p::t>(key)[1][0]);
254  match &= (v2.get(i).template get<p::t>(key)[1][1] == g1.template get<p::t>(key)[1][1]);
255  match &= (v2.get(i).template get<p::t>(key)[1][2] == g1.template get<p::t>(key)[1][2]);
256  match &= (v2.get(i).template get<p::t>(key)[2][0] == g1.template get<p::t>(key)[2][0]);
257  match &= (v2.get(i).template get<p::t>(key)[2][1] == g1.template get<p::t>(key)[2][1]);
258  match &= (v2.get(i).template get<p::t>(key)[2][2] == g1.template get<p::t>(key)[2][2]);
259 
260  ++it;
261  }
262 
263  }
264  BOOST_REQUIRE_EQUAL(match,true);
265  }
266  }
267 }
268 
269 BOOST_AUTO_TEST_CASE (Vcluster_semantic_gather_5)
270 {
271  for (size_t i = 0 ; i < 100 ; i++)
272  {
273  Vcluster & vcl = create_vcluster();
274 
275  if (vcl.getProcessingUnits() >= 32)
276  {return;}
277 
278  size_t sz[] = {16,16};
279  grid_cpu<2,Point_test<float>> g1(sz);
280  g1.setMemory();
281  fill_grid<2>(g1);
282  openfpm::vector<grid_cpu<2,Point_test<float>>> v1;
283 
284  v1.add(g1);
285  v1.add(g1);
286  v1.add(g1);
287 
288  openfpm::vector<grid_cpu<2,Point_test<float>>> v2;
289 
290  vcl.SGather(v1,v2,1);
291 
292  typedef Point_test<float> p;
293 
294  if (vcl.getProcessUnitID() == 1)
295  {
296  size_t n = vcl.getProcessingUnits();
297  BOOST_REQUIRE_EQUAL(v2.size(),v1.size()*n);
298 
299  bool match = true;
300  for (size_t i = 0 ; i < v2.size() ; i++)
301  {
302  auto it = v2.get(i).getIterator();
303 
304  while (it.isNext())
305  {
306  grid_key_dx<2> key = it.get();
307 
308  match &= (v2.get(i).template get<p::x>(key) == g1.template get<p::x>(key));
309  match &= (v2.get(i).template get<p::y>(key) == g1.template get<p::y>(key));
310  match &= (v2.get(i).template get<p::z>(key) == g1.template get<p::z>(key));
311  match &= (v2.get(i).template get<p::s>(key) == g1.template get<p::s>(key));
312 
313  match &= (v2.get(i).template get<p::v>(key)[0] == g1.template get<p::v>(key)[0]);
314  match &= (v2.get(i).template get<p::v>(key)[1] == g1.template get<p::v>(key)[1]);
315  match &= (v2.get(i).template get<p::v>(key)[2] == g1.template get<p::v>(key)[2]);
316 
317  match &= (v2.get(i).template get<p::t>(key)[0][0] == g1.template get<p::t>(key)[0][0]);
318  match &= (v2.get(i).template get<p::t>(key)[0][1] == g1.template get<p::t>(key)[0][1]);
319  match &= (v2.get(i).template get<p::t>(key)[0][2] == g1.template get<p::t>(key)[0][2]);
320  match &= (v2.get(i).template get<p::t>(key)[1][0] == g1.template get<p::t>(key)[1][0]);
321  match &= (v2.get(i).template get<p::t>(key)[1][1] == g1.template get<p::t>(key)[1][1]);
322  match &= (v2.get(i).template get<p::t>(key)[1][2] == g1.template get<p::t>(key)[1][2]);
323  match &= (v2.get(i).template get<p::t>(key)[2][0] == g1.template get<p::t>(key)[2][0]);
324  match &= (v2.get(i).template get<p::t>(key)[2][1] == g1.template get<p::t>(key)[2][1]);
325  match &= (v2.get(i).template get<p::t>(key)[2][2] == g1.template get<p::t>(key)[2][2]);
326 
327  ++it;
328  }
329 
330  }
331  BOOST_REQUIRE_EQUAL(match,true);
332  }
333  }
334 }
335 
336 BOOST_AUTO_TEST_CASE (Vcluster_semantic_gather_6)
337 {
338  for (size_t i = 0 ; i < 100 ; i++)
339  {
340  Vcluster & vcl = create_vcluster();
341 
342  if (vcl.getProcessingUnits() >= 32)
343  {return;}
344 
345  openfpm::vector<openfpm::vector<openfpm::vector<size_t>>> v1;
346  openfpm::vector<openfpm::vector<size_t>> v1_int;
347  openfpm::vector<size_t> v1_int2;
348 
349  v1_int2.add((size_t)7);
350  v1_int2.add((size_t)7);
351 
352  v1_int.add(v1_int2);
353  v1_int.add(v1_int2);
354  v1_int.add(v1_int2);
355 
356  v1.add(v1_int);
357  v1.add(v1_int);
358  v1.add(v1_int);
359  v1.add(v1_int);
360 
361  openfpm::vector<openfpm::vector<openfpm::vector<size_t>>> v2;
362 
363  vcl.SGather(v1,v2,0);
364 
365  if (vcl.getProcessUnitID() == 0)
366  {
367  size_t n = vcl.getProcessingUnits();
368 
369  BOOST_REQUIRE_EQUAL(v2.size(),v1.size()*n);
370 
371  bool is_seven = true;
372  for (size_t i = 0 ; i < v2.size() ; i++)
373  {
374  for (size_t j = 0 ; j < v2.get(i).size() ; j++)
375  {
376  for (size_t k = 0 ; k < v2.get(i).get(j).size() ; k++)
377  is_seven &= (v2.get(i).get(j).get(k) == 7);
378  }
379  }
380  BOOST_REQUIRE_EQUAL(is_seven,true);
381  }
382  }
383 }
384 
385 BOOST_AUTO_TEST_CASE (Vcluster_semantic_gather_7)
386 {
387  for (size_t i = 0 ; i < 100 ; i++)
388  {
389  Vcluster & vcl = create_vcluster();
390 
391  if (vcl.getProcessingUnits() >= 32)
392  {return;}
393 
394  openfpm::vector<Point_test<float>> v1;
395 
396  Point_test<float> p1;
397  p1.fill();
398 
399  v1.resize(vcl.getProcessUnitID());
400 
401  for(size_t i = 0 ; i < vcl.getProcessUnitID() ; i++)
402  {v1.get(i) = p1;}
403 
404  openfpm::vector<openfpm::vector<Point_test<float>>> v2;
405 
406  vcl.SGather(v1,v2,0);
407 
408  typedef Point_test<float> p;
409 
410  if (vcl.getProcessUnitID() == 0)
411  {
412  size_t n = vcl.getProcessingUnits();
413  BOOST_REQUIRE_EQUAL(v2.size(),n);
414 
415  bool match = true;
416 
417  for (size_t i = 0 ; i < v2.size() ; i++)
418  {
419  for (size_t j = 0 ; j < v2.get(i).size() ; j++)
420  {
421  Point_test<float> p2 = v2.get(i).get(j);
422  //BOOST_REQUIRE(p2 == p1);
423 
424  match &= (p2.template get<p::x>() == p1.template get<p::x>());
425  match &= (p2.template get<p::y>() == p1.template get<p::y>());
426  match &= (p2.template get<p::z>() == p1.template get<p::z>());
427  match &= (p2.template get<p::s>() == p1.template get<p::s>());
428 
429  match &= (p2.template get<p::v>()[0] == p1.template get<p::v>()[0]);
430  match &= (p2.template get<p::v>()[1] == p1.template get<p::v>()[1]);
431  match &= (p2.template get<p::v>()[2] == p1.template get<p::v>()[2]);
432 
433  match &= (p2.template get<p::t>()[0][0] == p1.template get<p::t>()[0][0]);
434  match &= (p2.template get<p::t>()[0][1] == p1.template get<p::t>()[0][1]);
435  match &= (p2.template get<p::t>()[0][2] == p1.template get<p::t>()[0][2]);
436  match &= (p2.template get<p::t>()[1][0] == p1.template get<p::t>()[1][0]);
437  match &= (p2.template get<p::t>()[1][1] == p1.template get<p::t>()[1][1]);
438  match &= (p2.template get<p::t>()[1][2] == p1.template get<p::t>()[1][2]);
439  match &= (p2.template get<p::t>()[2][0] == p1.template get<p::t>()[2][0]);
440  match &= (p2.template get<p::t>()[2][1] == p1.template get<p::t>()[2][1]);
441  match &= (p2.template get<p::t>()[2][2] == p1.template get<p::t>()[2][2]);
442  }
443  }
444  BOOST_REQUIRE_EQUAL(match,true);
445  }
446  }
447 }
448 
449 BOOST_AUTO_TEST_CASE (Vcluster_semantic_gather_8)
450 {
451  for (size_t i = 0 ; i < 100 ; i++)
452  {
453  Vcluster & vcl = create_vcluster();
454 
455  if (vcl.getProcessingUnits() >= 32)
456  {return;}
457 
458  openfpm::vector<Box<3,size_t>> v1;
459 
460  Box<3,size_t> bx;
461  bx.setLow(0, 1);
462  bx.setLow(1, 2);
463  bx.setLow(2, 3);
464  bx.setHigh(0, 4);
465  bx.setHigh(1, 5);
466  bx.setHigh(2, 6);
467 
468 
469  v1.resize(vcl.getProcessUnitID());
470 
471  for(size_t i = 0 ; i < vcl.getProcessUnitID() ; i++)
472  v1.get(i) = bx;
473 
474  openfpm::vector<openfpm::vector<Box<3,size_t>>> v2;
475 
476  vcl.SGather(v1,v2,0);
477 
478  if (vcl.getProcessUnitID() == 0)
479  {
480  size_t n = vcl.getProcessingUnits();
481  BOOST_REQUIRE_EQUAL(v2.size(),n);
482 
483  for (size_t i = 0 ; i < v2.size() ; i++)
484  {
485  for (size_t j = 0 ; j < v2.get(i).size() ; j++)
486  {
487  Box<3,size_t> b2 = v2.get(i).get(j);
488  BOOST_REQUIRE(bx == b2);
489  }
490  }
491  }
492  }
493 }
494 
495 BOOST_AUTO_TEST_CASE (Vcluster_semantic_struct_gather)
496 {
497  for (size_t i = 0 ; i < 100 ; i++)
498  {
499  Vcluster & vcl = create_vcluster();
500 
501  if (vcl.getProcessingUnits() >= 32)
502  return;
503 
504  openfpm::vector<Aexample> v1;
505  v1.resize(vcl.getProcessUnitID());
506 
507  for(size_t i = 0 ; i < vcl.getProcessUnitID() ; i++)
508  {
509  v1.get(i).a = 5;
510  v1.get(i).b = 10.0;
511  v1.get(i).c = 11.0;
512  }
513 
514  openfpm::vector<Aexample> v2;
515 
516  vcl.SGather(v1,v2,(i%vcl.getProcessingUnits()));
517 
518  if (vcl.getProcessUnitID() == (i%vcl.getProcessingUnits()))
519  {
520  size_t n = vcl.getProcessingUnits();
521  BOOST_REQUIRE_EQUAL(v2.size(),n*(n-1)/2);
522 
523  bool is_correct = true;
524  for (size_t i = 0 ; i < v2.size() ; i++)
525  {
526  is_correct &= (v2.get(i).a == 5);
527  is_correct &= (v2.get(i).b == 10.0);
528  is_correct &= (v2.get(i).c == 11.0);
529  }
530 
531  BOOST_REQUIRE_EQUAL(is_correct,true);
532  }
533  if (vcl.getProcessUnitID() == 0 && i == 99)
534  std::cout << "Semantic gather test stop" << std::endl;
535  }
536 }
537 
538 #define SSCATTER_MAX 7
539 
540 BOOST_AUTO_TEST_CASE (Vcluster_semantic_scatter)
541 {
542  for (size_t i = 0 ; i < 100 ; i++)
543  {
544  Vcluster & vcl = create_vcluster();
545 
546  if (vcl.getProcessingUnits() >= 32)
547  {return;}
548 
549  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
550  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
551  nr = ((nr-1) * nr) / 2;
552 
553  size_t n_elements = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
554 
555  openfpm::vector<size_t> v1;
556  v1.resize(n_elements);
557 
558  for(size_t i = 0 ; i < n_elements ; i++)
559  {v1.get(i) = 5;}
560 
562 
563  openfpm::vector<size_t> v2;
564 
565  openfpm::vector<size_t> prc;
566  openfpm::vector<size_t> sz;
567 
568  // Scatter pattern
569  for (size_t i = 0 ; i < vcl.getProcessingUnits() ; i++)
570  {
571  sz.add(i % SSCATTER_MAX);
572  prc.add(i);
573  }
574 
575  vcl.SScatter(v1,v2,prc,sz,(i%vcl.getProcessingUnits()));
576 
578 
579  BOOST_REQUIRE_EQUAL(v2.size(),vcl.getProcessUnitID() % SSCATTER_MAX);
580 
581  bool is_five = true;
582  for (size_t i = 0 ; i < v2.size() ; i++)
583  is_five &= (v2.get(i) == 5);
584 
585  BOOST_REQUIRE_EQUAL(is_five,true);
586  }
587 }
588 
589 
590 BOOST_AUTO_TEST_CASE (Vcluster_semantic_struct_scatter)
591 {
592  for (size_t i = 0 ; i < 100 ; i++)
593  {
594  Vcluster & vcl = create_vcluster();
595 
596  if (vcl.getProcessingUnits() >= 32)
597  {return;}
598 
599  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
600  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
601  nr = ((nr-1) * nr) / 2;
602 
603  size_t n_elements = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
604 
605  openfpm::vector<size_t> v1;
606  v1.resize(n_elements);
607 
608  for(size_t i = 0 ; i < n_elements ; i++)
609  v1.get(i) = 5;
610 
611  openfpm::vector<size_t> v2;
612 
613  openfpm::vector<size_t> prc;
614  openfpm::vector<size_t> sz;
615 
616  // Scatter pattern
617  for (size_t i = 0 ; i < vcl.getProcessingUnits() ; i++)
618  {
619  sz.add(i % SSCATTER_MAX);
620  prc.add(i);
621  }
622 
623  vcl.SScatter(v1,v2,prc,sz,(i%vcl.getProcessingUnits()));
624 
625  if (vcl.getProcessUnitID() == (i%vcl.getProcessingUnits()))
626  {
627  BOOST_REQUIRE_EQUAL(v2.size(),vcl.getProcessUnitID() % SSCATTER_MAX);
628 
629  bool is_five = true;
630  for (size_t i = 0 ; i < v2.size() ; i++)
631  is_five &= (v2.get(i) == 5);
632 
633  BOOST_REQUIRE_EQUAL(is_five,true);
634  }
635  }
636 }
637 
638 
639 
640 BOOST_AUTO_TEST_CASE (Vcluster_semantic_sendrecv_all_unknown)
641 {
642  openfpm::vector<size_t> prc_recv2;
643  openfpm::vector<size_t> prc_recv3;
644 
645  openfpm::vector<size_t> sz_recv2;
646  openfpm::vector<size_t> sz_recv3;
647 
648  for (size_t i = 0 ; i < 100 ; i++)
649  {
650  Vcluster & vcl = create_vcluster();
651 
652  if (vcl.getProcessUnitID() == 0 && i == 0)
653  std::cout << "Semantic sendrecv test start" << std::endl;
654 
655 
656  if (vcl.getProcessingUnits() >= 32)
657  {return;}
658 
659  prc_recv2.clear();
660  prc_recv3.clear();
661  openfpm::vector<size_t> prc_send;
662  sz_recv2.clear();
663  sz_recv3.clear();
664 
666 
667  // A vector of vector we want to send each internal vector to one specified processor
668  openfpm::vector<openfpm::vector<size_t>> v1;
669 
670  // We use this empty vector to receive data
671  openfpm::vector<size_t> v2;
672 
673  // We use this empty vector to receive data
674  openfpm::vector<openfpm::vector<size_t>> v3;
675 
676  // in this case each processor will send a message of different size to all the other processor
677  // but can also be a subset of processors
678  v1.resize(vcl.getProcessingUnits());
679 
680  // We fill the send buffer with some sense-less data
681  for(size_t i = 0 ; i < v1.size() ; i++)
682  {
683  // each vector is filled with a different message size
684  for (size_t j = 0 ; j < i % SSCATTER_MAX ; j++)
685  v1.get(i).add(j);
686 
687  // generate the sending list (in this case the sendinf list is all the other processor)
688  // but in general can be some of them and totally random
689  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
690  }
691 
692  // Send and receive from the other processor v2 container the received data
693  // Because in this case v2 is an openfpm::vector<size_t>, all the received
694  // vector are concatenated one over the other. For example if the processor receive 3 openfpm::vector<size_t>
695  // each having 3,4,5 elements. v2 will be a vector of 12 elements
696  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
697 
698  // Send and receive from the other processors v2 contain the received data
699  // Because in this case v2 is an openfpm::vector<openfpm::vector<size_t>>, all the vector from
700  // each processor will be collected. For example if the processor receive 3 openfpm::vector<size_t>
701  // each having 3,4,5 elements. v2 will be a vector of vector of 3 elements (openfpm::vector) and
702  // each element will be respectivly 3,4,5 elements
703  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
704 
706 
707  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
708  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
709  nr = ((nr-1) * nr) / 2;
710 
711  size_t n_ele = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
712 
713  BOOST_REQUIRE_EQUAL(v2.size(),n_ele);
714  size_t nc_check = (vcl.getProcessingUnits()-1) / SSCATTER_MAX;
715  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits()-1-nc_check);
716 
717  bool match = true;
718  size_t s = 0;
719 
720  for (size_t i = 0 ; i < sz_recv2.size() ; i++)
721  {
722  for (size_t j = 0 ; j < sz_recv2.get(i); j++)
723  {
724  match &= v2.get(s+j) == j;
725  }
726  s += sz_recv2.get(i);
727  }
728 
729  BOOST_REQUIRE_EQUAL(match,true);
730 
731  for (size_t i = 0 ; i < v3.size() ; i++)
732  {
733  for (size_t j = 0 ; j < v3.get(i).size() ; j++)
734  {
735  match &= v3.get(i).get(j) == j;
736  }
737  }
738 
739  BOOST_REQUIRE_EQUAL(match,true);
740  }
741 }
742 
743 
744 BOOST_AUTO_TEST_CASE (Vcluster_semantic_sendrecv_receive_size_known)
745 {
746  openfpm::vector<size_t> prc_recv2;
747  openfpm::vector<size_t> prc_recv3;
748 
749  openfpm::vector<size_t> sz_recv2;
750  openfpm::vector<size_t> sz_recv3;
751 
752  for (size_t i = 0 ; i < 100 ; i++)
753  {
754  Vcluster & vcl = create_vcluster();
755 
756  if (vcl.getProcessUnitID() == 0 && i == 0)
757  {std::cout << "Semantic sendrecv test start" << std::endl;}
758 
759 
760  if (vcl.getProcessingUnits() >= 32)
761  {return;}
762 
763  openfpm::vector<size_t> prc_send;
764 
765  openfpm::vector<openfpm::vector<size_t>> v1;
766  openfpm::vector<size_t> v2;
767  openfpm::vector<openfpm::vector<size_t>> v3;
768 
769  v1.resize(vcl.getProcessingUnits());
770 
771  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
772  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
773  nr = ((nr-1) * nr) / 2;
774 
775  size_t n_ele = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
776 
777  for(size_t i = 0 ; i < v1.size() ; i++)
778  {
779  for (size_t j = 0 ; j < i % SSCATTER_MAX ; j++)
780  v1.get(i).add(j);
781 
782  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
783  }
784 
785  // We receive to fill prc_recv2 and sz_recv2
786  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
787 
788  // We reset v2 and we receive again saying that the processors are known and we know the elements
789  v2.clear();
790  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2,RECEIVE_KNOWN | KNOWN_ELEMENT_OR_BYTE);
791  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
792 
793  BOOST_REQUIRE_EQUAL(v2.size(),n_ele);
794  size_t nc_check = (vcl.getProcessingUnits()-1) / SSCATTER_MAX;
795  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits()-1-nc_check);
796 
797  bool match = true;
798  size_t s = 0;
799 
800  for (size_t i = 0 ; i < sz_recv2.size() ; i++)
801  {
802  for (size_t j = 0 ; j < sz_recv2.get(i); j++)
803  {
804  match &= v2.get(s+j) == j;
805  }
806  s += sz_recv2.get(i);
807  }
808 
809  BOOST_REQUIRE_EQUAL(match,true);
810 
811  for (size_t i = 0 ; i < v3.size() ; i++)
812  {
813  for (size_t j = 0 ; j < v3.get(i).size() ; j++)
814  {
815  match &= v3.get(i).get(j) == j;
816  }
817  }
818 
819  BOOST_REQUIRE_EQUAL(match,true);
820  }
821 }
822 
823 
824 
825 BOOST_AUTO_TEST_CASE (Vcluster_semantic_sendrecv_receive_known)
826 {
827  openfpm::vector<size_t> prc_recv2;
828  openfpm::vector<size_t> prc_recv3;
829 
830  openfpm::vector<size_t> sz_recv2;
831  openfpm::vector<size_t> sz_recv3;
832 
833  for (size_t i = 0 ; i < 100 ; i++)
834  {
835  Vcluster & vcl = create_vcluster();
836 
837  if (vcl.getProcessUnitID() == 0 && i == 0)
838  {std::cout << "Semantic sendrecv test start" << std::endl;}
839 
840 
841  if (vcl.getProcessingUnits() >= 32)
842  {return;}
843 
844  openfpm::vector<size_t> prc_send;
845 
846  openfpm::vector<openfpm::vector<size_t>> v1;
847  openfpm::vector<size_t> v2;
848  openfpm::vector<openfpm::vector<size_t>> v3;
849 
850  v1.resize(vcl.getProcessingUnits());
851 
852  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
853  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
854  nr = ((nr-1) * nr) / 2;
855 
856  size_t n_ele = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
857 
858  for(size_t i = 0 ; i < v1.size() ; i++)
859  {
860  for (size_t j = 0 ; j < i % SSCATTER_MAX ; j++)
861  v1.get(i).add(j);
862 
863  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
864  }
865 
866  // Receive to fill prc_recv2
867  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
868 
869  // Reset v2 and sz_recv2
870 
871  v2.clear();
872  sz_recv2.clear();
873 
874  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2,RECEIVE_KNOWN);
875  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
876 
877  BOOST_REQUIRE_EQUAL(v2.size(),n_ele);
878  size_t nc_check = (vcl.getProcessingUnits()-1) / SSCATTER_MAX;
879  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits()-1-nc_check);
880 
881  bool match = true;
882  size_t s = 0;
883 
884  for (size_t i = 0 ; i < sz_recv2.size() ; i++)
885  {
886  for (size_t j = 0 ; j < sz_recv2.get(i); j++)
887  {
888  match &= v2.get(s+j) == j;
889  }
890  s += sz_recv2.get(i);
891  }
892 
893  BOOST_REQUIRE_EQUAL(match,true);
894 
895  for (size_t i = 0 ; i < v3.size() ; i++)
896  {
897  for (size_t j = 0 ; j < v3.get(i).size() ; j++)
898  {
899  match &= v3.get(i).get(j) == j;
900  }
901  }
902 
903  BOOST_REQUIRE_EQUAL(match,true);
904  }
905 }
906 
907 BOOST_AUTO_TEST_CASE (Vcluster_semantic_struct_sendrecv)
908 {
909  for (size_t i = 0 ; i < 100 ; i++)
910  {
911  Vcluster & vcl = create_vcluster();
912 
913  if (vcl.getProcessingUnits() >= 32)
914  {return;}
915 
916  openfpm::vector<size_t> prc_recv2;
917  openfpm::vector<size_t> prc_recv3;
918  openfpm::vector<size_t> prc_send;
919  openfpm::vector<size_t> sz_recv2;
920  openfpm::vector<size_t> sz_recv3;
921  openfpm::vector<openfpm::vector<Box<3,size_t>>> v1;
922  openfpm::vector<Box<3,size_t>> v2;
923  openfpm::vector<openfpm::vector<Box<3,size_t>>> v3;
924 
925  v1.resize(vcl.getProcessingUnits());
926 
927  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
928  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
929  nr = ((nr-1) * nr) / 2;
930 
931  size_t n_ele = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
932 
933  for(size_t i = 0 ; i < v1.size() ; i++)
934  {
935  for (size_t j = 0 ; j < i % SSCATTER_MAX ; j++)
936  {
937  Box<3,size_t> b({j,j,j},{j,j,j});
938  v1.get(i).add(b);
939  }
940 
941  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
942  }
943 
944  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
945  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
946 
947  BOOST_REQUIRE_EQUAL(v2.size(),n_ele);
948  size_t nc_check = (vcl.getProcessingUnits()-1) / SSCATTER_MAX;
949  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits()-1-nc_check);
950 
951  bool match = true;
952  size_t s = 0;
953 
954  for (size_t i = 0 ; i < sz_recv2.size() ; i++)
955  {
956  for (size_t j = 0 ; j < sz_recv2.get(i); j++)
957  {
958  Box<3,size_t> b({j,j,j},{j,j,j});
959  Box<3,size_t> bt = v2.get(s+j);
960  match &= bt == b;
961  }
962  s += sz_recv2.get(i);
963  }
964 
965  BOOST_REQUIRE_EQUAL(match,true);
966 
967  for (size_t i = 0 ; i < v3.size() ; i++)
968  {
969  for (size_t j = 0 ; j < v3.get(i).size() ; j++)
970  {
971  Box<3,size_t> b({j,j,j},{j,j,j});
972  Box<3,size_t> bt = v3.get(i).get(j);
973  match &= bt == b;
974  }
975  }
976 
977  BOOST_REQUIRE_EQUAL(match,true);
978  }
979 
980  // Send and receive 0 and check
981 
982  {
983  Vcluster & vcl = create_vcluster();
984 
985  openfpm::vector<size_t> prc_recv2;
986  openfpm::vector<size_t> prc_send;
987  openfpm::vector<size_t> sz_recv2;
988  openfpm::vector<openfpm::vector<Box<3,size_t>>> v1;
989  openfpm::vector<Box<3,size_t>> v2;
990 
991  v1.resize(vcl.getProcessingUnits());
992 
993 
994  for(size_t i = 0 ; i < v1.size() ; i++)
995  {
996  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
997  }
998 
999  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
1000 
1001  BOOST_REQUIRE_EQUAL(v2.size(),0ul);
1002  BOOST_REQUIRE_EQUAL(prc_recv2.size(),0ul);
1003  BOOST_REQUIRE_EQUAL(sz_recv2.size(),0ul);
1004  }
1005 }
1006 
1007 BOOST_AUTO_TEST_CASE (Vcluster_semantic_sendrecv_2)
1008 {
1009  for (size_t i = 0 ; i < 100 ; i++)
1010  {
1011  Vcluster & vcl = create_vcluster();
1012 
1013  if (vcl.getProcessingUnits() >= 32)
1014  return;
1015 
1016  openfpm::vector<size_t> prc_recv2;
1017  openfpm::vector<size_t> prc_recv3;
1018  openfpm::vector<size_t> prc_send;
1019  openfpm::vector<size_t> sz_recv2;
1020  openfpm::vector<size_t> sz_recv3;
1021 
1022  openfpm::vector<openfpm::vector<aggregate<openfpm::vector<size_t>>> > v1;
1023  openfpm::vector<aggregate<openfpm::vector<size_t>>> v2;
1024  openfpm::vector<openfpm::vector<aggregate<openfpm::vector<size_t>>> > v3;
1025 
1026  openfpm::vector<aggregate<openfpm::vector<size_t>>> v1_int;
1027  aggregate<openfpm::vector<size_t>> aggr;
1028  openfpm::vector<size_t> v1_int2;
1029 
1030  v1_int2.add(7);
1031  v1_int2.add(7);
1032  v1_int2.add(7);
1033 
1034  aggr.template get<0>() = v1_int2;
1035 
1036  v1_int.add(aggr);
1037  v1_int.add(aggr);
1038  v1_int.add(aggr);
1039 
1040  v1.resize(vcl.getProcessingUnits());
1041 
1042  for(size_t i = 0 ; i < v1.size() ; i++)
1043  {
1044  for (size_t j = 0 ; j < i % SSCATTER_MAX ; j++)
1045  {
1046  v1.get(i).add(aggr);
1047  }
1048 
1049  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
1050  }
1051 
1052  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
1053  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
1054  nr = ((nr-1) * nr) / 2;
1055 
1056  size_t n_ele = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
1057 
1058  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
1059 
1060  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
1061 
1062  BOOST_REQUIRE_EQUAL(v2.size(),n_ele);
1063 
1064  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits());
1065 
1066  bool match = true;
1067  bool is_seven = true;
1068  size_t s = 0;
1069 
1070  for (size_t i = 0 ; i < sz_recv2.size() ; i++)
1071  {
1072  for (size_t j = 0 ; j < sz_recv2.get(i); j++)
1073  {
1074  for (size_t k = 0; k < v2.get(s+j).template get<0>().size(); k++)
1075  is_seven &= (v2.get(s+j).template get<0>().get(k) == 7);
1076  }
1077  s += sz_recv2.get(i);
1078  }
1079 
1080  BOOST_REQUIRE_EQUAL(is_seven,true);
1081  BOOST_REQUIRE_EQUAL(match,true);
1082 
1083  for (size_t i = 0 ; i < v3.size() ; i++)
1084  {
1085  for (size_t j = 0 ; j < v3.get(i).size(); j++)
1086  {
1087  for (size_t k = 0; k < v3.get(i).template get<0>(j).size(); k++)
1088  is_seven &= (v3.get(i).template get<0>(j).get(k) == 7);
1089  }
1090  }
1091 
1092  BOOST_REQUIRE_EQUAL(is_seven,true);
1093  BOOST_REQUIRE_EQUAL(match,true);
1094  }
1095 }
1096 
1097 BOOST_AUTO_TEST_CASE (Vcluster_semantic_sendrecv_3)
1098 {
1099  for (size_t i = 0 ; i < 100 ; i++)
1100  {
1101  Vcluster & vcl = create_vcluster();
1102 
1103  if (vcl.getProcessingUnits() >= 32)
1104  return;
1105 
1106  openfpm::vector<size_t> prc_recv2;
1107  openfpm::vector<size_t> prc_recv3;
1108  openfpm::vector<size_t> prc_send;
1109  openfpm::vector<size_t> sz_recv2;
1110  openfpm::vector<size_t> sz_recv3;
1111 
1112  openfpm::vector<openfpm::vector<aggregate<float, openfpm::vector<size_t>, Point_test<float>>> > v1;
1113  openfpm::vector<aggregate<float, openfpm::vector<size_t>, Point_test<float>>> v2;
1114  openfpm::vector<openfpm::vector<aggregate<float, openfpm::vector<size_t>, Point_test<float>>> > v3;
1115 
1116  openfpm::vector<aggregate<float, openfpm::vector<size_t>, Point_test<float>>> v1_int;
1117  aggregate<float, openfpm::vector<size_t>, Point_test<float>> aggr;
1118  openfpm::vector<size_t> v1_int2;
1119 
1120  v1_int2.add((size_t)7);
1121  v1_int2.add((size_t)7);
1122 
1123  aggr.template get<0>() = 7;
1124  aggr.template get<1>() = v1_int2;
1125 
1126  typedef Point_test<float> p;
1127  p p1;
1128  p1.fill();
1129  aggr.template get<2>() = p1;
1130 
1131  v1_int.add(aggr);
1132  v1_int.add(aggr);
1133  v1_int.add(aggr);
1134 
1135  v1.resize(vcl.getProcessingUnits());
1136 
1137  for(size_t i = 0 ; i < v1.size() ; i++)
1138  {
1139  for (size_t j = 0 ; j < i % SSCATTER_MAX ; j++)
1140  {
1141  v1.get(i).add(aggr);
1142  }
1143 
1144  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
1145  }
1146 
1147  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
1148  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
1149  nr = ((nr-1) * nr) / 2;
1150 
1151  size_t n_ele = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
1152 
1153  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
1154 
1155  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
1156 
1157  BOOST_REQUIRE_EQUAL(v2.size(),n_ele);
1158 
1159  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits());
1160 
1161  bool match = true;
1162  bool is_seven = true;
1163  size_t s = 0;
1164 
1165  for (size_t i = 0 ; i < sz_recv2.size() ; i++)
1166  {
1167  for (size_t j = 0 ; j < sz_recv2.get(i); j++)
1168  {
1169  is_seven &= (v2.get(s+j).template get<0>() == 7);
1170 
1171  for (size_t k = 0; k < v2.get(s+j).template get<1>().size(); k++)
1172  is_seven &= (v2.get(s+j).template get<1>().get(k) == 7);
1173 
1174  Point_test<float> p2 = v2.get(s+j).template get<2>();
1175 
1176  match &= (p2.template get<p::x>() == p1.template get<p::x>());
1177  match &= (p2.template get<p::y>() == p1.template get<p::y>());
1178  match &= (p2.template get<p::z>() == p1.template get<p::z>());
1179  match &= (p2.template get<p::s>() == p1.template get<p::s>());
1180 
1181  match &= (p2.template get<p::v>()[0] == p1.template get<p::v>()[0]);
1182  match &= (p2.template get<p::v>()[1] == p1.template get<p::v>()[1]);
1183  match &= (p2.template get<p::v>()[2] == p1.template get<p::v>()[2]);
1184 
1185  match &= (p2.template get<p::t>()[0][0] == p1.template get<p::t>()[0][0]);
1186  match &= (p2.template get<p::t>()[0][1] == p1.template get<p::t>()[0][1]);
1187  match &= (p2.template get<p::t>()[0][2] == p1.template get<p::t>()[0][2]);
1188  match &= (p2.template get<p::t>()[1][0] == p1.template get<p::t>()[1][0]);
1189  match &= (p2.template get<p::t>()[1][1] == p1.template get<p::t>()[1][1]);
1190  match &= (p2.template get<p::t>()[1][2] == p1.template get<p::t>()[1][2]);
1191  match &= (p2.template get<p::t>()[2][0] == p1.template get<p::t>()[2][0]);
1192  match &= (p2.template get<p::t>()[2][1] == p1.template get<p::t>()[2][1]);
1193  match &= (p2.template get<p::t>()[2][2] == p1.template get<p::t>()[2][2]);
1194  }
1195  s += sz_recv2.get(i);
1196  }
1197 
1198  BOOST_REQUIRE_EQUAL(is_seven,true);
1199  BOOST_REQUIRE_EQUAL(match,true);
1200 
1201  for (size_t i = 0 ; i < v3.size() ; i++)
1202  {
1203  for (size_t j = 0 ; j < v3.get(i).size(); j++)
1204  {
1205  is_seven &= (v3.get(i).get(j).template get<0>() == 7);
1206 
1207  for (size_t k = 0; k < v3.get(i).get(j).template get<1>().size(); k++)
1208  is_seven &= (v3.get(i).get(j).template get<1>().get(k) == 7);
1209 
1210  Point_test<float> p2 = v3.get(i).get(j).template get<2>();
1211 
1212  match &= (p2.template get<p::x>() == p1.template get<p::x>());
1213  match &= (p2.template get<p::y>() == p1.template get<p::y>());
1214  match &= (p2.template get<p::z>() == p1.template get<p::z>());
1215  match &= (p2.template get<p::s>() == p1.template get<p::s>());
1216 
1217  match &= (p2.template get<p::v>()[0] == p1.template get<p::v>()[0]);
1218  match &= (p2.template get<p::v>()[1] == p1.template get<p::v>()[1]);
1219  match &= (p2.template get<p::v>()[2] == p1.template get<p::v>()[2]);
1220 
1221  match &= (p2.template get<p::t>()[0][0] == p1.template get<p::t>()[0][0]);
1222  match &= (p2.template get<p::t>()[0][1] == p1.template get<p::t>()[0][1]);
1223  match &= (p2.template get<p::t>()[0][2] == p1.template get<p::t>()[0][2]);
1224  match &= (p2.template get<p::t>()[1][0] == p1.template get<p::t>()[1][0]);
1225  match &= (p2.template get<p::t>()[1][1] == p1.template get<p::t>()[1][1]);
1226  match &= (p2.template get<p::t>()[1][2] == p1.template get<p::t>()[1][2]);
1227  match &= (p2.template get<p::t>()[2][0] == p1.template get<p::t>()[2][0]);
1228  match &= (p2.template get<p::t>()[2][1] == p1.template get<p::t>()[2][1]);
1229  match &= (p2.template get<p::t>()[2][2] == p1.template get<p::t>()[2][2]);
1230  }
1231  }
1232 
1233  BOOST_REQUIRE_EQUAL(is_seven,true);
1234  BOOST_REQUIRE_EQUAL(match,true);
1235  }
1236 }
1237 
1238 BOOST_AUTO_TEST_CASE (Vcluster_semantic_sendrecv_4)
1239 {
1240  for (size_t i = 0 ; i < 100 ; i++)
1241  {
1242  Vcluster & vcl = create_vcluster();
1243 
1244  if (vcl.getProcessingUnits() >= 32)
1245  return;
1246 
1247  openfpm::vector<size_t> prc_recv2;
1248  openfpm::vector<size_t> prc_recv3;
1249  openfpm::vector<size_t> prc_send;
1250  openfpm::vector<size_t> sz_recv2;
1251  openfpm::vector<size_t> sz_recv3;
1252  openfpm::vector<openfpm::vector<aggregate<float,Point_test<float>>> > v1;
1253  openfpm::vector<aggregate<float,Point_test<float>> > v2;
1254  openfpm::vector<openfpm::vector<aggregate<float,Point_test<float>>> > v3;
1255 
1256  v1.resize(vcl.getProcessingUnits());
1257 
1258  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
1259  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
1260  nr = ((nr-1) * nr) / 2;
1261 
1262  size_t n_ele = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
1263 
1264  //Prepare an aggregate
1265  aggregate<float, Point_test<float> > aggr;
1266 
1267  typedef Point_test<float> p;
1268 
1269  p p1;
1270  p1.fill();
1271 
1272  aggr.template get<0>() = 7;
1273  aggr.template get<1>() = p1;
1274 
1275  //Fill v1 with aggregates
1276  for(size_t i = 0 ; i < v1.size() ; i++)
1277  {
1278  for (size_t j = 0 ; j < i % SSCATTER_MAX ; j++)
1279  {
1280  v1.get(i).add(aggr);
1281  }
1282 
1283  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
1284  }
1285 
1286  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
1287  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
1288 
1289  BOOST_REQUIRE_EQUAL(v2.size(),n_ele);
1290  size_t nc_check = (vcl.getProcessingUnits()-1) / SSCATTER_MAX;
1291  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits()-1-nc_check);
1292  bool match = true;
1293  bool is_seven = true;
1294  size_t s = 0;
1295 
1296  for (size_t i = 0 ; i < sz_recv2.size() ; i++)
1297  {
1298  for (size_t j = 0 ; j < sz_recv2.get(i); j++)
1299  {
1300  is_seven &= (v2.get(s+j).template get<0>() == 7);
1301 
1302  Point_test<float> p2 = v2.get(s+j).template get<1>();
1303 
1304  match &= (p2.template get<p::x>() == p1.template get<p::x>());
1305  match &= (p2.template get<p::y>() == p1.template get<p::y>());
1306  match &= (p2.template get<p::z>() == p1.template get<p::z>());
1307  match &= (p2.template get<p::s>() == p1.template get<p::s>());
1308 
1309  match &= (p2.template get<p::v>()[0] == p1.template get<p::v>()[0]);
1310  match &= (p2.template get<p::v>()[1] == p1.template get<p::v>()[1]);
1311  match &= (p2.template get<p::v>()[2] == p1.template get<p::v>()[2]);
1312 
1313  match &= (p2.template get<p::t>()[0][0] == p1.template get<p::t>()[0][0]);
1314  match &= (p2.template get<p::t>()[0][1] == p1.template get<p::t>()[0][1]);
1315  match &= (p2.template get<p::t>()[0][2] == p1.template get<p::t>()[0][2]);
1316  match &= (p2.template get<p::t>()[1][0] == p1.template get<p::t>()[1][0]);
1317  match &= (p2.template get<p::t>()[1][1] == p1.template get<p::t>()[1][1]);
1318  match &= (p2.template get<p::t>()[1][2] == p1.template get<p::t>()[1][2]);
1319  match &= (p2.template get<p::t>()[2][0] == p1.template get<p::t>()[2][0]);
1320  match &= (p2.template get<p::t>()[2][1] == p1.template get<p::t>()[2][1]);
1321  match &= (p2.template get<p::t>()[2][2] == p1.template get<p::t>()[2][2]);
1322  }
1323  s += sz_recv2.get(i);
1324  }
1325 
1326  BOOST_REQUIRE_EQUAL(is_seven,true);
1327  BOOST_REQUIRE_EQUAL(match,true);
1328 
1329  for (size_t i = 0 ; i < v3.size() ; i++)
1330  {
1331  for (size_t j = 0 ; j < v3.get(i).size() ; j++)
1332  {
1333  is_seven &= (v3.get(i).get(j).template get<0>() == 7);
1334 
1335  Point_test<float> p2 = v3.get(i).get(j).template get<1>();
1336 
1337  match &= (p2.template get<p::x>() == p1.template get<p::x>());
1338  match &= (p2.template get<p::y>() == p1.template get<p::y>());
1339  match &= (p2.template get<p::z>() == p1.template get<p::z>());
1340  match &= (p2.template get<p::s>() == p1.template get<p::s>());
1341 
1342  match &= (p2.template get<p::v>()[0] == p1.template get<p::v>()[0]);
1343  match &= (p2.template get<p::v>()[1] == p1.template get<p::v>()[1]);
1344  match &= (p2.template get<p::v>()[2] == p1.template get<p::v>()[2]);
1345 
1346  match &= (p2.template get<p::t>()[0][0] == p1.template get<p::t>()[0][0]);
1347  match &= (p2.template get<p::t>()[0][1] == p1.template get<p::t>()[0][1]);
1348  match &= (p2.template get<p::t>()[0][2] == p1.template get<p::t>()[0][2]);
1349  match &= (p2.template get<p::t>()[1][0] == p1.template get<p::t>()[1][0]);
1350  match &= (p2.template get<p::t>()[1][1] == p1.template get<p::t>()[1][1]);
1351  match &= (p2.template get<p::t>()[1][2] == p1.template get<p::t>()[1][2]);
1352  match &= (p2.template get<p::t>()[2][0] == p1.template get<p::t>()[2][0]);
1353  match &= (p2.template get<p::t>()[2][1] == p1.template get<p::t>()[2][1]);
1354  match &= (p2.template get<p::t>()[2][2] == p1.template get<p::t>()[2][2]);
1355  }
1356  }
1357 
1358  BOOST_REQUIRE_EQUAL(is_seven,true);
1359  BOOST_REQUIRE_EQUAL(match,true);
1360  }
1361 }
1362 
1363 BOOST_AUTO_TEST_CASE (Vcluster_semantic_sendrecv_5)
1364 {
1365  for (size_t i = 0 ; i < 100 ; i++)
1366  {
1367  Vcluster & vcl = create_vcluster();
1368 
1369  if (vcl.getProcessingUnits() >= 32)
1370  return;
1371 
1372  openfpm::vector<size_t> prc_recv2;
1373  openfpm::vector<size_t> prc_recv3;
1374  openfpm::vector<size_t> prc_send;
1375  openfpm::vector<size_t> sz_recv2;
1376  openfpm::vector<size_t> sz_recv3;
1377 
1378  size_t sz[] = {16,16};
1379 
1380  grid_cpu<2,Point_test<float>> g1(sz);
1381  g1.setMemory();
1382  fill_grid<2>(g1);
1383 
1384  aggregate<grid_cpu<2,Point_test<float>>> aggr;
1385  aggr.template get<0>() = g1;
1386 
1387 
1388  openfpm::vector<openfpm::vector<aggregate<grid_cpu<2,Point_test<float>>>> > v1;
1389  openfpm::vector<aggregate<grid_cpu<2,Point_test<float>>> > v2;
1390  openfpm::vector<openfpm::vector<aggregate<grid_cpu<2,Point_test<float>>>> > v3;
1391 
1392  v1.resize(vcl.getProcessingUnits());
1393 
1394  for(size_t i = 0 ; i < v1.size() ; i++)
1395  {
1396  for (size_t j = 0 ; j < i % SSCATTER_MAX ; j++)
1397  {
1398  v1.get(i).add(aggr);
1399  }
1400 
1401  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
1402  }
1403 
1404  size_t nc = vcl.getProcessingUnits() / SSCATTER_MAX;
1405  size_t nr = vcl.getProcessingUnits() - nc * SSCATTER_MAX;
1406  nr = ((nr-1) * nr) / 2;
1407 
1408  size_t n_ele = nc * SSCATTER_MAX * (SSCATTER_MAX - 1) / 2 + nr;
1409 
1410  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
1411 
1412  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
1413 
1414  BOOST_REQUIRE_EQUAL(v2.size(),n_ele);
1415 
1416  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits());
1417 
1418  bool match = true;
1419  size_t s = 0;
1420  typedef Point_test<float> p;
1421 
1422  for (size_t i = 0 ; i < sz_recv2.size() ; i++)
1423  {
1424  for (size_t j = 0 ; j < sz_recv2.get(i); j++)
1425  {
1426  grid_cpu<2,Point_test<float>> g2 = v2.get(s+j).template get<0>();
1427 
1428  auto it = g2.getIterator();
1429 
1430  while (it.isNext())
1431  {
1432  grid_key_dx<2> key = it.get();
1433 
1434  match &= (g2.template get<p::x>(key) == g1.template get<p::x>(key));
1435  match &= (g2.template get<p::y>(key) == g1.template get<p::y>(key));
1436  match &= (g2.template get<p::z>(key) == g1.template get<p::z>(key));
1437  match &= (g2.template get<p::s>(key) == g1.template get<p::s>(key));
1438 
1439  match &= (g2.template get<p::v>(key)[0] == g1.template get<p::v>(key)[0]);
1440  match &= (g2.template get<p::v>(key)[1] == g1.template get<p::v>(key)[1]);
1441  match &= (g2.template get<p::v>(key)[2] == g1.template get<p::v>(key)[2]);
1442 
1443  match &= (g2.template get<p::t>(key)[0][0] == g1.template get<p::t>(key)[0][0]);
1444  match &= (g2.template get<p::t>(key)[0][1] == g1.template get<p::t>(key)[0][1]);
1445  match &= (g2.template get<p::t>(key)[0][2] == g1.template get<p::t>(key)[0][2]);
1446  match &= (g2.template get<p::t>(key)[1][0] == g1.template get<p::t>(key)[1][0]);
1447  match &= (g2.template get<p::t>(key)[1][1] == g1.template get<p::t>(key)[1][1]);
1448  match &= (g2.template get<p::t>(key)[1][2] == g1.template get<p::t>(key)[1][2]);
1449  match &= (g2.template get<p::t>(key)[2][0] == g1.template get<p::t>(key)[2][0]);
1450  match &= (g2.template get<p::t>(key)[2][1] == g1.template get<p::t>(key)[2][1]);
1451  match &= (g2.template get<p::t>(key)[2][2] == g1.template get<p::t>(key)[2][2]);
1452 
1453  ++it;
1454  }
1455  }
1456  s += sz_recv2.get(i);
1457  }
1458  BOOST_REQUIRE_EQUAL(match,true);
1459 
1460  for (size_t i = 0 ; i < v3.size() ; i++)
1461  {
1462  for (size_t j = 0 ; j < v3.get(i).size(); j++)
1463  {
1464  grid_cpu<2,Point_test<float>> g2 = v3.get(i).get(j).template get<0>();
1465 
1466  auto it = g2.getIterator();
1467 
1468  while (it.isNext())
1469  {
1470  grid_key_dx<2> key = it.get();
1471 
1472  match &= (g2.template get<p::x>(key) == g1.template get<p::x>(key));
1473  match &= (g2.template get<p::y>(key) == g1.template get<p::y>(key));
1474  match &= (g2.template get<p::z>(key) == g1.template get<p::z>(key));
1475  match &= (g2.template get<p::s>(key) == g1.template get<p::s>(key));
1476 
1477  match &= (g2.template get<p::v>(key)[0] == g1.template get<p::v>(key)[0]);
1478  match &= (g2.template get<p::v>(key)[1] == g1.template get<p::v>(key)[1]);
1479  match &= (g2.template get<p::v>(key)[2] == g1.template get<p::v>(key)[2]);
1480 
1481  match &= (g2.template get<p::t>(key)[0][0] == g1.template get<p::t>(key)[0][0]);
1482  match &= (g2.template get<p::t>(key)[0][1] == g1.template get<p::t>(key)[0][1]);
1483  match &= (g2.template get<p::t>(key)[0][2] == g1.template get<p::t>(key)[0][2]);
1484  match &= (g2.template get<p::t>(key)[1][0] == g1.template get<p::t>(key)[1][0]);
1485  match &= (g2.template get<p::t>(key)[1][1] == g1.template get<p::t>(key)[1][1]);
1486  match &= (g2.template get<p::t>(key)[1][2] == g1.template get<p::t>(key)[1][2]);
1487  match &= (g2.template get<p::t>(key)[2][0] == g1.template get<p::t>(key)[2][0]);
1488  match &= (g2.template get<p::t>(key)[2][1] == g1.template get<p::t>(key)[2][1]);
1489  match &= (g2.template get<p::t>(key)[2][2] == g1.template get<p::t>(key)[2][2]);
1490 
1491  ++it;
1492  }
1493  }
1494  }
1495  BOOST_REQUIRE_EQUAL(match,true);
1496  }
1497 }
1498 
1499 BOOST_AUTO_TEST_CASE (Vcluster_semantic_sendrecv_6)
1500 {
1501  for (size_t i = 0 ; i < 100 ; i++)
1502  {
1503  Vcluster & vcl = create_vcluster();
1504 
1505  if (vcl.getProcessingUnits() >= 32)
1506  return;
1507 
1508  openfpm::vector<size_t> prc_recv2;
1509  openfpm::vector<size_t> prc_recv3;
1510  openfpm::vector<size_t> prc_send;
1511  openfpm::vector<size_t> sz_recv2;
1512  openfpm::vector<size_t> sz_recv3;
1513 
1514  size_t sz[] = {8,10};
1515 
1516  grid_cpu<2,Point_test<float>> g1(sz);
1517  g1.setMemory();
1518  fill_grid<2>(g1);
1519 
1520  openfpm::vector<grid_cpu<2,Point_test<float>>> v1;
1521  openfpm::vector<grid_cpu<2,Point_test<float>>> v3;
1522 
1523  v1.resize(vcl.getProcessingUnits());
1524 
1525  for(size_t i = 0 ; i < v1.size() ; i++)
1526  {
1527  v1.get(i) = g1;
1528 
1529  prc_send.add((i + vcl.getProcessUnitID()) % vcl.getProcessingUnits());
1530  }
1531 
1532  vcl.SSendRecv(v1,v3,prc_send,prc_recv3,sz_recv3);
1533 
1534  BOOST_REQUIRE_EQUAL(v3.size(),vcl.getProcessingUnits());
1535 
1536  bool match = true;
1537  typedef Point_test<float> p;
1538 
1539  for (size_t i = 0 ; i < v3.size() ; i++)
1540  {
1541  for (size_t j = 0 ; j < v3.get(i).size(); j++)
1542  {
1543  grid_cpu<2,Point_test<float>> g2 = v3.get(i);
1544 
1545  auto it = g2.getIterator();
1546 
1547  while (it.isNext())
1548  {
1549  grid_key_dx<2> key = it.get();
1550 
1551  match &= (g2.template get<p::x>(key) == g1.template get<p::x>(key));
1552  match &= (g2.template get<p::y>(key) == g1.template get<p::y>(key));
1553  match &= (g2.template get<p::z>(key) == g1.template get<p::z>(key));
1554  match &= (g2.template get<p::s>(key) == g1.template get<p::s>(key));
1555 
1556  match &= (g2.template get<p::v>(key)[0] == g1.template get<p::v>(key)[0]);
1557  match &= (g2.template get<p::v>(key)[1] == g1.template get<p::v>(key)[1]);
1558  match &= (g2.template get<p::v>(key)[2] == g1.template get<p::v>(key)[2]);
1559 
1560  match &= (g2.template get<p::t>(key)[0][0] == g1.template get<p::t>(key)[0][0]);
1561  match &= (g2.template get<p::t>(key)[0][1] == g1.template get<p::t>(key)[0][1]);
1562  match &= (g2.template get<p::t>(key)[0][2] == g1.template get<p::t>(key)[0][2]);
1563  match &= (g2.template get<p::t>(key)[1][0] == g1.template get<p::t>(key)[1][0]);
1564  match &= (g2.template get<p::t>(key)[1][1] == g1.template get<p::t>(key)[1][1]);
1565  match &= (g2.template get<p::t>(key)[1][2] == g1.template get<p::t>(key)[1][2]);
1566  match &= (g2.template get<p::t>(key)[2][0] == g1.template get<p::t>(key)[2][0]);
1567  match &= (g2.template get<p::t>(key)[2][1] == g1.template get<p::t>(key)[2][1]);
1568  match &= (g2.template get<p::t>(key)[2][2] == g1.template get<p::t>(key)[2][2]);
1569 
1570  ++it;
1571  }
1572  }
1573  }
1574  BOOST_REQUIRE_EQUAL(match,true);
1575 
1576  if (vcl.getProcessUnitID() == 0 && i == 99)
1577  std::cout << "Semantic sendrecv test start" << std::endl;
1578  }
1579 }
1580 
1581 /*BOOST_AUTO_TEST_CASE (Vcluster_semantic_bench_all_all)
1582 {
1583  Vcluster & vcl = create_vcluster();
1584 
1585  if (vcl.getProcessingUnits() >= 32)
1586  return;
1587 
1588  openfpm::vector<size_t> prc_recv2;
1589  openfpm::vector<size_t> prc_recv3;
1590  openfpm::vector<size_t> prc_send;
1591  openfpm::vector<size_t> sz_recv2;
1592  openfpm::vector<size_t> sz_recv3;
1593  openfpm::vector<openfpm::vector<Box<3,size_t>>> v1;
1594  openfpm::vector<Box<3,size_t>> v2;
1595  openfpm::vector<openfpm::vector<Box<3,size_t>>> v3;
1596 
1597  v1.resize(vcl.getProcessingUnits());
1598 
1599  for(size_t i = 0 ; i < v1.size() ; i++)
1600  {
1601  for (size_t j = 0 ; j < 1000000 ; j++)
1602  {
1603  Box<3,size_t> b({j,j,j},{j,j,j});
1604  v1.get(i).add(b);
1605  }
1606 
1607  prc_send.add(i);
1608  }
1609 
1610  timer comm_time;
1611  comm_time.start();
1612 
1613  vcl.SSendRecv(v1,v2,prc_send,prc_recv2,sz_recv2);
1614 
1615  comm_time.stop();
1616  std::cout << "Communication time " << comm_time.getwct() << std::endl;
1617 
1618  std::cout << "Total sent: " << tot_sent << " Tot recv: " << tot_recv << std::endl;
1619 
1620  std::cout << "END" << std::endl;
1621 }*/
1622 
1623 
1624 BOOST_AUTO_TEST_SUITE_END()
1625 
1626 #endif /* OPENFPM_VCLUSTER_SRC_VCLUSTER_SEMANTIC_UNIT_TESTS_HPP_ */
grid_cpu
Definition: map_grid.hpp:65
grid_key_dx
grid_key_dx is the key to access any element in the grid
Definition: grid_key.hpp:18
Vcluster_base::getProcessUnitID
size_t getProcessUnitID()
Get the process unit id.
Definition: VCluster_base.hpp:356
Aexample::a
size_t a
Example size_t.
Definition: VCluster_semantic_unit_tests.hpp:18
Aexample
Example structure.
Definition: VCluster_semantic_unit_tests.hpp:15
Box::setHigh
void setHigh(int i, T val)
set the high interval of the box
Definition: Box.hpp:467
openfpm::vector::size
size_t size()
Stub size.
Definition: map_vector.hpp:70
grid_key_dx::get
mem_id get(size_t i) const
Get the i index.
Definition: grid_key.hpp:394
Vcluster
Implementation of VCluster class.
Definition: VCluster.hpp:36
Point_test::fill
void fill()
fill
Definition: Point_test.hpp:366
Vcluster::SSendRecv
bool SSendRecv(openfpm::vector< T > &send, S &recv, openfpm::vector< size_t > &prc_send, openfpm::vector< size_t > &prc_recv, openfpm::vector< size_t > &sz_recv, size_t opt=NONE)
Semantic Send and receive, send the data to processors and receive from the other processors...
Definition: VCluster.hpp:639
Vcluster::SGather
bool SGather(T &send, S &recv, size_t root)
Semantic Gather, gather the data from all processors into one node.
Definition: VCluster.hpp:330
Box::setLow
void setLow(int i, T val)
set the low interval of the box
Definition: Box.hpp:456
Box
This class represent an N-dimensional box.
Definition: Box.hpp:56
key
This class is a trick to indicate the compiler a specific specialization pattern. ...
Definition: memory_c.hpp:201
Aexample::c
double c
Example double.
Definition: VCluster_semantic_unit_tests.hpp:24
Aexample::b
float b
Example float.
Definition: VCluster_semantic_unit_tests.hpp:21
aggregate
aggregate of properties, from a list of object if create a struct that follow the OPENFPM native stru...
Definition: aggregate.hpp:81
Vcluster::SScatter
bool SScatter(T &send, S &recv, openfpm::vector< size_t > &prc, openfpm::vector< size_t > &sz, size_t root)
Semantic Scatter, scatter the data from one processor to the other node.
Definition: VCluster.hpp:481
Point_test
Test structure used for several test.
Definition: Point_test.hpp:105
Vcluster_base::getProcessingUnits
size_t getProcessingUnits()
Get the total number of processors.
Definition: VCluster_base.hpp:332