OpenFPM_pdata  4.1.0
Project that contain the implementation of distributed structures
 
Loading...
Searching...
No Matches
grid_unit_tests.hpp
1#ifndef GRID_UNIT_TEST_HPP
2#define GRID_UNIT_TEST_HPP
3
4#include "config.h"
5#include "map_grid.hpp"
6#include "Point_test.hpp"
7#include "Space/Shape/HyperCube.hpp"
8#include "timer.hpp"
9#include "grid_util_test.hpp"
10#include "grid_test_utils.hpp"
11
12#ifdef TEST_COVERAGE_MODE
13constexpr int GS_SIZE = 8;
14#else
15constexpr int GS_SIZE = 128;
16#endif
17
18template<unsigned int dim, typename g> void test_layout_gridNd(g & c3, size_t sz);
19template<unsigned int dim, typename g> void test_layout_gridObjNd(g & c3, size_t sz);
20template<typename g> void test_layout_grid3d(g & c3, size_t sz);
21
27template<unsigned int dim> void test_all_grid(size_t sz)
28{
29 size_t szz[dim];
30
31 for (size_t i = 0 ; i < dim ; i++)
32 {szz[i] = sz;}
33
34 {grid_cpu<dim, Point_test<float> > c3(szz);
35 c3.setMemory();
36 test_layout_gridNd<dim>(c3,sz);}
37
38 {grid_cpu<dim, Point_test<float> > c3(szz);
39 c3.setMemory();
40 test_layout_gridObjNd<dim>(c3,sz);}
41
42#ifdef CUDA_GPU
43
44 {grid_gpu<dim, Point_test<float> > c3(szz);
45 c3.setMemory();
46 test_layout_gridNd<dim>(c3,sz);}
47
48 {grid_gpu<dim, Point_test<float> > c3(szz);
49 c3.setMemory();
50 test_layout_gridObjNd<dim>(c3,sz);}
51
52#endif
53
54 {grid_cpu<dim, Point_test<float> > c3(szz);
55 c3.setMemory();
56 test_layout_gridObjNd<dim>(c3,sz);}
57
58 {grid_cpu<dim, Point_test<float> > c3(szz);
59 c3.setMemory();
60 test_layout_gridNd<dim>(c3,sz);}
61
62#ifdef CUDA_GPU
63
64 {grid_gpu<dim, Point_test<float> > c3(szz);
65 c3.setMemory();
66 test_layout_gridNd<dim>(c3,sz);}
67
68 {grid_gpu<dim, Point_test<float> > c3(szz);
69 c3.setMemory();
70 test_layout_gridObjNd<dim>(c3,sz);}
71
72#endif
73}
74
75
76
77template<typename g> void test_layout_grid3d(g & c3, size_t sz)
78{
79
80#ifdef VERBOSE_TEST
81 std::cout << "3D Array with grid_key (without redundant dimension): " << "\n";
82#endif
83
85 typedef Point_test<float> P;
86
87 timer t;
88 t.start();
89
90 grid_key_dx<3> kk;
91
92 for (size_t i = 0 ; i < sz ; i++)
93 {
94 for (size_t j = 0 ; j < sz ; j++)
95 {
96 for (size_t k = 0 ; k < sz ; k++)
97 {
98
99 kk.set(i,j,k);
100
101 c3.template get<P::x>(kk) = 1.1f;
102 c3.template get<P::y>(kk) = 1.2f;
103 c3.template get<P::z>(kk) = 1.3f;
104 c3.template get<P::s>(kk) = 1.0f;
105
106 c3.template get<P::v>(kk)[0] = 1.0f;
107 c3.template get<P::v>(kk)[1] = 2.0f;
108 c3.template get<P::v>(kk)[2] = 3.0f;
109
110 c3.template get<P::t>(kk)[0][0] = 1.0f;
111 c3.template get<P::t>(kk)[0][1] = 2.0f;
112 c3.template get<P::t>(kk)[0][2] = 3.0f;
113 c3.template get<P::t>(kk)[1][0] = 4.0f;
114 c3.template get<P::t>(kk)[1][1] = 5.0f;
115 c3.template get<P::t>(kk)[1][2] = 6.0f;
116 c3.template get<P::t>(kk)[2][0] = 7.0f;
117 c3.template get<P::t>(kk)[2][1] = 8.0f;
118 c3.template get<P::t>(kk)[2][2] = 9.0f;
119
120 }
121 }
122 }
123
125
126#ifdef VERBOSE_TEST
127 t.stop();
128
129 std::cout << "End : " << sz*sz*sz*16*4 << " Byte " << " Bandwidth: " << sz*sz*sz*16*4/1024/1024/t.getwct() << " MB/s ";
130#endif
131
133
134 bool passed = true;
135
136 for (size_t i = 0 ; i < sz ; i++)
137 {
138 for (size_t j = 0 ; j < sz ; j++)
139 {
140 for (size_t k = 0 ; k < sz ; k++)
141 {
142 kk.set(i,j,k);
143
144 c3.template get<P::x>(kk) = i;
145 c3.template get<P::y>(kk) = j;
146 c3.template get<P::z>(kk) = k;
147 c3.template get<P::s>(kk) = i+j+k;
148
149 c3.template get<P::v>(kk)[0] = i;
150 c3.template get<P::v>(kk)[1] = j;
151 c3.template get<P::v>(kk)[2] = k;
152
153 c3.template get<P::t>(kk)[0][0] = i+i;
154 c3.template get<P::t>(kk)[0][1] = i+j;
155 c3.template get<P::t>(kk)[0][2] = i+k;
156 c3.template get<P::t>(kk)[1][0] = j+i;
157 c3.template get<P::t>(kk)[1][1] = j+j;
158 c3.template get<P::t>(kk)[1][2] = j+k;
159 c3.template get<P::t>(kk)[2][0] = k+i;
160 c3.template get<P::t>(kk)[2][1] = k+j;
161 c3.template get<P::t>(kk)[2][2] = k+k;
162 }
163 }
164 }
165
166 for (size_t i = 0 ; i < sz ; i++)
167 {
168 for (size_t j = 0 ; j < sz ; j++)
169 {
170 for (size_t k = 0 ; k < sz ; k++)
171 {
172 kk.set(i,j,k);
173
174 if (c3.template get<P::x>(kk) != i) passed = false;
175 if (c3.template get<P::y>(kk) != j) passed = false;
176 if (c3.template get<P::z>(kk) != k) passed = false;
177 if (c3.template get<P::s>(kk) != i+j+k) passed = false;
178
179 if (c3.template get<P::v>(kk)[0] != i) passed = false;
180 if (c3.template get<P::v>(kk)[1] != j) passed = false;
181 if (c3.template get<P::v>(kk)[2] != k) passed = false;
182
183 if (c3.template get<P::t>(kk)[0][0] != i+i) passed = false;
184 if (c3.template get<P::t>(kk)[0][1] != i+j) passed = false;
185 if (c3.template get<P::t>(kk)[0][2] != i+k) passed = false;
186 if (c3.template get<P::t>(kk)[1][0] != j+i) passed = false;
187 if (c3.template get<P::t>(kk)[1][1] != j+j) passed = false;
188 if (c3.template get<P::t>(kk)[1][2] != j+k) passed = false;
189 if (c3.template get<P::t>(kk)[2][0] != k+i) passed = false;
190 if (c3.template get<P::t>(kk)[2][1] != k+j) passed = false;
191 if (c3.template get<P::t>(kk)[2][2] != k+k) passed = false;
192 }
193 }
194 }
195
196 BOOST_REQUIRE_EQUAL(passed,true);
197}
198
199template<unsigned int dim, typename g> void test_layout_gridObjNd(g & c3, size_t sz)
200{
201#ifdef VERBOSE_TEST
202 std::cout << dim << "D Array with grid_key (without redundant dimension): " << "\n";
203
204 timer t;
205 t.start();
206#endif
207
209
210 typedef Point_test<float> P;
211
212 grid_key_dx_iterator<dim> key_it = c3.getIterator();
213
214 while (key_it.isNext())
215 {
216 grid_key_dx<dim> kk = key_it.get();
217
218 // Here we get a reference to the object, in reality we get an encapsulated object reference encapc
219 auto v = c3.get_o(kk);
220
221 // An encapsulated object can be accessed like that
222 // (this will change the value in the grid)
223 v.template get<P::x>() = 1.1f;
224 v.template get<P::y>() = 1.2f;
225 v.template get<P::z>() = 1.3f;
226 v.template get<P::s>() = 1.0f;
227
228 v.template get<P::v>()[0] = 1.0f;
229 v.template get<P::v>()[1] = 2.0f;
230 v.template get<P::v>()[2] = 3.0f;
231
232 v.template get<P::t>()[0][0] = 1.0f;
233 v.template get<P::t>()[0][1] = 2.0f;
234 v.template get<P::t>()[0][2] = 3.0f;
235 v.template get<P::t>()[1][0] = 4.0f;
236 v.template get<P::t>()[1][1] = 5.0f;
237 v.template get<P::t>()[1][2] = 6.0f;
238 v.template get<P::t>()[2][0] = 7.0f;
239 v.template get<P::t>()[2][1] = 8.0f;
240 v.template get<P::t>()[2][2] = 9.0f;
241
242 // From an encapsulated reference object you can create
243 // an object
244 Point_test<float> obj = c3.get_o(kk);
245
246 // And do some operation
247 obj.fill();
248
249 // Note change obj does not change the grid
250
251 ++key_it;
252
253 }
254
256
257#ifdef VERBOSE_TEST
258 t.stop();
259
260 std::cout << "End : " << pow(sz,dim)*16*4/1024/1024 << " MB " << " Bandwidth: " << pow(sz,dim)*16*4/1024/1024/t.getect() << " MB/s " << "\n";
261#endif
262
264
265 bool passed = true;
266
268 fill_grid<dim>(c3);
269
270 key_it = c3.getIterator();
271
272 while (key_it.isNext())
273 {
274 grid_key_dx<dim> kk = key_it.get();
275
276 if (c3.template get<P::x>(kk) != c3.getGrid().LinId(kk)) passed = false;
277 if (c3.template get<P::y>(kk) != c3.getGrid().LinId(kk)+1) passed = false;
278 if (c3.template get<P::z>(kk) != c3.getGrid().LinId(kk)+2) passed = false;
279 if (c3.template get<P::s>(kk) != c3.getGrid().LinId(kk)+3) passed = false;
280
281 if (c3.template get<P::v>(kk)[0] != c3.getGrid().LinId(kk)+123) passed = false;
282 if (c3.template get<P::v>(kk)[1] != c3.getGrid().LinId(kk)+124) passed = false;
283 if (c3.template get<P::v>(kk)[2] != c3.getGrid().LinId(kk)+125) passed = false;
284
285 if (c3.template get<P::t>(kk)[0][0] != c3.getGrid().LinId(kk)+567) passed = false;
286 if (c3.template get<P::t>(kk)[0][1] != c3.getGrid().LinId(kk)+568) passed = false;
287 if (c3.template get<P::t>(kk)[0][2] != c3.getGrid().LinId(kk)+569) passed = false;
288 if (c3.template get<P::t>(kk)[1][0] != c3.getGrid().LinId(kk)+570) passed = false;
289 if (c3.template get<P::t>(kk)[1][1] != c3.getGrid().LinId(kk)+571) passed = false;
290 if (c3.template get<P::t>(kk)[1][2] != c3.getGrid().LinId(kk)+572) passed = false;
291 if (c3.template get<P::t>(kk)[2][0] != c3.getGrid().LinId(kk)+573) passed = false;
292 if (c3.template get<P::t>(kk)[2][1] != c3.getGrid().LinId(kk)+574) passed = false;
293 if (c3.template get<P::t>(kk)[2][2] != c3.getGrid().LinId(kk)+575) passed = false;
294
295 ++key_it;
296 }
297
298 BOOST_REQUIRE_EQUAL(passed,true);
299}
300
301
302BOOST_AUTO_TEST_SUITE( grid_test )
303
304BOOST_AUTO_TEST_CASE( grid_safety_check )
305{
306#if defined(SE_CLASS1) && defined (THROW_ON_ERROR)
307
308 bool error = false;
309
310 typedef Point_test<float> p;
311
312 size_t sz[] = {16,16,16};
313
314 // Create a grid
315
316 grid_cpu<3,Point_test<float>> g(sz);
317 grid_cpu<3,Point_test<float>> g2(sz);
318
319
320
321 // try to access uninitialized grid
322 grid_key_dx<3> keyOut(23,1,1);
323 grid_key_dx<3> keyGood(15,1,1);
324 grid_key_dx<3> keyNeg(-1,0,0);
325
326 error = false;
327 try
328 {g.get<p::x>(keyOut);}
329 catch (std::exception & e)
330 {
331 error = true;
332 BOOST_REQUIRE_EQUAL(e.what(),"Runtime grid error");
333 }
334 BOOST_REQUIRE_EQUAL(error,true);
335
336 error = false;
337 g.setMemory();
338 try
339 {g.get<p::x>(keyOut);}
340 catch (std::exception & e)
341 {
342 error = true;
343 BOOST_REQUIRE_EQUAL(e.what(),"Runtime grid error");
344 }
345 BOOST_REQUIRE_EQUAL(error,true);
346
347 error = false;
348 Point_test<float> t;
349 try
350 {g.set(keyOut,t);}
351 catch (std::exception & e)
352 {
353 error = true;
354 BOOST_REQUIRE_EQUAL(e.what(),"Runtime grid error");
355 }
356 BOOST_REQUIRE_EQUAL(error,true);
357
358 error = false;
359 try
360 {g.set(keyGood,g2,keyOut);}
361 catch (std::exception & e)
362 {
363 error = true;
364 BOOST_REQUIRE_EQUAL(e.what(),"Runtime grid error");
365 }
366 BOOST_REQUIRE_EQUAL(error,true);
367
369
370 error = false;
371 try
372 {g.get<p::x>(keyNeg);}
373 catch (std::exception & e)
374 {
375 error = true;
376 BOOST_REQUIRE_EQUAL(e.what(),"Runtime grid error");
377 }
378 BOOST_REQUIRE_EQUAL(error,true);
379
380 error = false;
381 Point_test<float> t2;
382 try
383 {g.set(keyNeg,t2);}
384 catch (std::exception & e)
385 {
386 error = true;
387 BOOST_REQUIRE_EQUAL(e.what(),"Runtime grid error");
388 }
389 BOOST_REQUIRE_EQUAL(error,true);
390
391 error = false;
392 try
393 {g.set(keyGood,g2,keyNeg);}
394 catch (std::exception & e)
395 {
396 error = true;
397 BOOST_REQUIRE_EQUAL(e.what(),"Runtime grid error");
398 }
399 BOOST_REQUIRE_EQUAL(error,true);
400
401#endif
402}
403
404BOOST_AUTO_TEST_CASE( grid_set_prp_check )
405{
406 size_t szz[2] = {8,8};
407
408 grid_cpu<2, Point_test<float> > c2(szz);
409 grid_cpu<2, Point_test<float> > c1(szz);
410
411 c1.setMemory();
412 c2.setMemory();
413
414 grid_key_dx<2> k1({0,0});
415
416 c2.template get<1>(k1) = 5.0;
417
418 c1.template set<1>(k1,c2,k1);
419
420 BOOST_REQUIRE_EQUAL(c1.template get<1>(k1),5.0);
421}
422
423BOOST_AUTO_TEST_CASE( grid_use)
424{
425 /* tensor<int,3,3,3> c;
426 tensor<tensor<int,3,3,3>,3,3,3> c2;*/
427
428 std::cout << "Grid unit test start" << "\n";
429
430 size_t sz[3] = {GS_SIZE,GS_SIZE,GS_SIZE};
431
432 // test the grid from dimensionality 1 to 8 with several size non multiple of two
433 // Dimension 8-1
434
435 // With test coverage reduce the test size
436
437#ifndef TEST_COVERAGE_MODE
438 test_all_grid<8>(4);
439 test_all_grid<7>(8);
440 test_all_grid<6>(9);
441 test_all_grid<5>(18);
442 test_all_grid<4>(37);
443 test_all_grid<3>(126);
444 test_all_grid<2>(1414);
445 test_all_grid<1>(2000000);
446
447
448 // Special case grid of size 0
449 test_all_grid<8>(0);
450 test_all_grid<7>(0);
451 test_all_grid<6>(0);
452 test_all_grid<5>(0);
453 test_all_grid<4>(0);
454 test_all_grid<3>(0);
455 test_all_grid<2>(0);
456 test_all_grid<1>(0);
457#else
458 test_all_grid<4>(4);
459 test_all_grid<3>(8);
460 test_all_grid<2>(16);
461 test_all_grid<1>(256);
462#endif
463
464 // Test the 3d gpu grid with CudaMemory and HeapMemory with different size
465
466 for (int i = 0 ; i <= GS_SIZE ; i++)
467 {
468#ifdef CUDA_GPU
469
470 {
472 grid_gpu<3, Point_test<float> > c3(sz);
473 c3.setMemory();
475 test_layout_grid3d(c3,i);
476 }
477
478#endif
479
480 {grid_cpu<3, Point_test<float> > c3(sz);
481 c3.setMemory();
482 test_layout_grid3d(c3,i);}
483
484 {
486 grid_cpu<3, Point_test<float> > c3(sz);
487 c3.setMemory();
489 test_layout_grid3d(c3,i);}
490
491 // Test the 3d cpu grid with Cudamemory and HeapMemory
492
493 {grid_cpu<3, Point_test<float> > c3(sz);
494 c3.setMemory();
495 test_layout_grid3d(c3,i);}
496
497 }
498
499 std::cout << "Grid unit test end" << "\n";
500}
501
502BOOST_AUTO_TEST_CASE( grid_use_smb)
503{
504 /* tensor<int,3,3,3> c;
505 tensor<tensor<int,3,3,3>,3,3,3> c2;*/
506
507 std::cout << "Grid smb unit test start" << "\n";
508
509 size_t sz[3] = {GS_SIZE,GS_SIZE,GS_SIZE};
510
511
512 // Test the 3d gpu grid with CudaMemory and HeapMemory with different size
513
514 for (int i = 0 ; i <= GS_SIZE ; i+=4)
515 {
516#ifdef CUDA_GPU
517
518 {
520 grid_gpu<3, Point_test<float>, grid_smb<3,4> > c3(sz);
521 c3.setMemory();
523 test_layout_grid3d(c3,i);
524 }
525
526#endif
527
528 {grid_cpu<3, Point_test<float>, grid_smb<3,4> > c3(sz);
529 c3.setMemory();
530 test_layout_grid3d(c3,i);}
531
532 {
534 grid_cpu<3, Point_test<float>, grid_smb<3,4> > c3(sz);
535 c3.setMemory();
537 test_layout_grid3d(c3,i);}
538
539 // Test the 3d cpu grid with Cudamemory and HeapMemory
540
541 {grid_cpu<3, Point_test<float>, grid_smb<3,4> > c3(sz);
542 c3.setMemory();
543 test_layout_grid3d(c3,i);}
544
545 }
546
547 std::cout << "Grid unit test end" << "\n";
548}
549
550BOOST_AUTO_TEST_CASE( grid_use_zmb)
551{
552 /* tensor<int,3,3,3> c;
553 tensor<tensor<int,3,3,3>,3,3,3> c2;*/
554
555 std::cout << "Grid zmb unit test start" << "\n";
556
557 size_t sz[3] = {GS_SIZE,GS_SIZE,GS_SIZE};
558
559 // Test the 3d gpu grid with CudaMemory and HeapMemory with different size
560
561 for (int i = 4 ; i <= GS_SIZE ; i*=2)
562 {
563#ifdef CUDA_GPU
564
565 {
567 grid_gpu<3, Point_test<float>, grid_zmb<3,4, long int> > c3(sz);
568 c3.setMemory();
570 test_layout_grid3d(c3,i);
571 }
572
573#endif
574
575 {grid_cpu<3, Point_test<float>, grid_zmb<3,4, long int> > c3(sz);
576 c3.setMemory();
577 test_layout_grid3d(c3,i);}
578
579 {
581 grid_cpu<3, Point_test<float>, grid_zmb<3,4, long int> > c3(sz);
582 c3.setMemory();
584 test_layout_grid3d(c3,i);}
585
586 // Test the 3d cpu grid with Cudamemory and HeapMemory
587
588 {grid_cpu<3, Point_test<float>, grid_zmb<3,4, long int> > c3(sz);
589 c3.setMemory();
590 test_layout_grid3d(c3,i);}
591
592 }
593
594 std::cout << "Grid unit test end" << "\n";
595}
596
597/* \brief This is an ordinary test simple 3D with plain C array
598 *
599 * This is an ordinary test simple 3D with plain C array
600 *
601 */
602
603BOOST_AUTO_TEST_CASE( C_array_test )
604{
605 // Testing the grids
606
607#ifdef VERBOSE_TEST
608 std::cout << "Grid size known at runtime" << "\n";
609 std::cout << "1D Array with index calculation: " << "\n";
610#endif
611
612 Point_orig<float> * pA = new Point_orig<float>[GS_SIZE*GS_SIZE*GS_SIZE];
613
614 int gs_sq = GS_SIZE*GS_SIZE;
615 int gs = GS_SIZE;
616
617#ifdef VERBOSE_TEST
618 timer t;
619 t.start();
620#endif
621
622 for (int i = 0 ; i < GS_SIZE ; i++)
623 {
624 for (int j = 0 ; j < GS_SIZE ; j++)
625 {
626 for (int k = 0 ; k < GS_SIZE ; k++)
627 {
628 pA[i*gs_sq+j*gs+k].x = 1.1f;
629 pA[i*gs_sq+j*gs+k].y = 1.2f;
630 pA[i*gs_sq+j*gs+k].z = 1.3f;
631 pA[i*gs_sq+j*gs+k].s = 1.0f;
632
633 pA[i*gs_sq+j*gs+k].v[0] = 1.0f;
634 pA[i*gs_sq+j*gs+k].v[1] = 2.0f;
635 pA[i*gs_sq+j*gs+k].v[2] = 3.0f;
636
637 pA[i*gs_sq+j*gs+k].t[0][0] = 1.0f;
638 pA[i*gs_sq+j*gs+k].t[0][1] = 2.0f;
639 pA[i*gs_sq+j*gs+k].t[0][2] = 3.0f;
640 pA[i*gs_sq+j*gs+k].t[1][0] = 4.0f;
641 pA[i*gs_sq+j*gs+k].t[1][1] = 5.0f;
642 pA[i*gs_sq+j*gs+k].t[1][2] = 6.0f;
643 pA[i*gs_sq+j*gs+k].t[2][0] = 7.0f;
644 pA[i*gs_sq+j*gs+k].t[2][1] = 8.0f;
645 pA[i*gs_sq+j*gs+k].t[2][2] = 9.0f;
646 }
647 }
648 }
649
650 delete [] pA;
651
652#ifdef VERBOSE_TEST
653 t.stop();
654
655 std::cout << "End : " << GS_SIZE*GS_SIZE*GS_SIZE*16*4/1024/1024 << " MB " << " Bandwidth: " << GS_SIZE*GS_SIZE*GS_SIZE*16*4/1024/1024/t.getcputime() << " MB/s \n";
656#endif
657}
658
659BOOST_AUTO_TEST_CASE(grid_operator_equal)
660{
662
663 size_t sz[] = {16,16};
664
665 typedef Box<2,float> b;
666
667 grid_cpu<2,Box<2,float>> g1(sz);
668 g1.setMemory();
669
670 auto it = g1.getIterator();
671
672 while (it.isNext())
673 {
674 auto key = it.get();
675
676 g1.get<b::p1>(key)[0] = key.get(0);
677 g1.get<b::p2>(key)[1] = key.get(1);
678
679 ++it;
680 }
681
682 grid_cpu<2,Box<2,float>> g2;
683 g2 = g1;
684
686
687 bool ret = (g2 == g1);
688
689 BOOST_REQUIRE_EQUAL(ret,true);
690}
691
699void fill_2_grid_data(grid_cpu<2,Box<2,float>> & g1, grid_cpu<2,Box<2,float>> & g2)
700{
701 typedef Box<2,float> b;
702
703 auto it1 = g1.getIterator();
704
705 while (it1.isNext())
706 {
707 auto key = it1.get();
708
709 g1.get<b::p1>(key)[0] = key.get(0);
710 g1.get<b::p2>(key)[1] = key.get(1);
711
712 ++it1;
713 }
714
715 auto it2 = g2.getIterator();
716
717 while (it2.isNext())
718 {
719 auto key = it2.get();
720
721 g2.get<b::p1>(key)[0] = key.get(0);
722 g2.get<b::p2>(key)[1] = key.get(1);
723
724 ++it2;
725 }
726
727
728}
729
730BOOST_AUTO_TEST_CASE(grid_operator_swap)
731{
732 size_t sz1[] = {16,16};
733 size_t sz2[] = {5,5};
734
735 grid_cpu<2,Box<2,float>> g1_old(sz1);
736 g1_old.setMemory();
737 grid_cpu<2,Box<2,float>> g2_old(sz2);
738 g2_old.setMemory();
739 grid_cpu<2,Box<2,float>> g1(sz1);
740 g1.setMemory();
741 grid_cpu<2,Box<2,float>> g2(sz2);
742 g2.setMemory();
743
744 fill_2_grid_data(g1_old,g2_old);
745 fill_2_grid_data(g1,g2);
746
748
749 g2.swap(g1);
750
752
753 bool ret = (g2 == g1_old);
754 BOOST_REQUIRE_EQUAL(ret,true);
755 ret = (g1 == g2_old);
756 BOOST_REQUIRE_EQUAL(ret,true);
757}
758
759BOOST_AUTO_TEST_CASE(grid_resize_less)
760{
761 size_t sz1[] = {256,256};
762 size_t sz2[] = {5,5};
763
764 grid_cpu<2,Box<2,float>> g1(sz1);
765 g1.setMemory();
766
767 fill_2_grid_data(g1,g1);
768
769
770 g1.resize(sz2);
771
772 BOOST_REQUIRE_EQUAL(g1.size(),25ul);
773}
774
775BOOST_AUTO_TEST_CASE(copy_encap_vector_fusion_test)
776{
777 size_t sz2[] = {5,5};
778 grid_cpu<2,aggregate<float,float[3],float[3][3]>> g(sz2);
779 g.setMemory();
780
781 aggregate<float,float[3],float[3][3]>::type tmp;
782
783 grid_key_dx<2> key({0,0});
784 grid_key_dx<2> key1({1,1});
785
786 g.template get<0>(key) = 1.0;
787
788 g.template get<1>(key)[0] = 2.0;
789 g.template get<1>(key)[1] = 3.0;
790 g.template get<1>(key)[2] = 4.0;
791
792 g.template get<2>(key)[0][0] = 5.0;
793 g.template get<2>(key)[0][1] = 6.0;
794 g.template get<2>(key)[0][2] = 7.0;
795 g.template get<2>(key)[1][0] = 8.0;
796 g.template get<2>(key)[1][1] = 9.0;
797 g.template get<2>(key)[1][2] = 10.0;
798 g.template get<2>(key)[2][0] = 11.0;
799 g.template get<2>(key)[2][1] = 12.0;
800 g.template get<2>(key)[2][2] = 13.0;
801
802 auto ge = g.get_o(key);
803 copy_encap_vector_fusion<decltype(g.get_o(key)),typename aggregate<float,float[3],float[3][3]>::type> cp(ge,tmp);
804 boost::mpl::for_each_ref< boost::mpl::range_c<int,0,aggregate<float,float[3],float[3][3]>::max_prop> >(cp);
805
806 g.get_o(key1) = tmp;
807
808 BOOST_REQUIRE_EQUAL(g.template get<0>(key),g.template get<0>(key1));
809
810 BOOST_REQUIRE_EQUAL(g.template get<1>(key)[0],g.template get<1>(key1)[0]);
811 BOOST_REQUIRE_EQUAL(g.template get<1>(key)[1],g.template get<1>(key1)[1]);
812 BOOST_REQUIRE_EQUAL(g.template get<1>(key)[2],g.template get<1>(key1)[2]);
813
814 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[0][0],g.template get<2>(key1)[0][0]);
815 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[0][1],g.template get<2>(key1)[0][1]);
816 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[0][2],g.template get<2>(key1)[0][2]);
817 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[1][0],g.template get<2>(key1)[1][0]);
818 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[1][1],g.template get<2>(key1)[1][1]);
819 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[1][2],g.template get<2>(key1)[1][2]);
820 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[2][0],g.template get<2>(key1)[2][0]);
821 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[2][1],g.template get<2>(key1)[2][1]);
822 BOOST_REQUIRE_EQUAL(g.template get<2>(key)[2][2],g.template get<2>(key1)[2][2]);
823}
824
825
826BOOST_AUTO_TEST_CASE(grid_test_copy_to)
827{
828 size_t sz_dst[] = {5,5};
829 size_t sz_src[] = {3,2};
830 grid_cpu<2,aggregate<float,float[3],float[3][3]>> g_dst(sz_dst);
831 grid_cpu<2,aggregate<float,float[3],float[3][3]>> g_src(sz_src);
832
833 Box<2,size_t> box_dst({1,2},{2,3});
834 Box<2,size_t> box_src({1,0},{2,1});
835
836 copy_test(g_src,g_dst,box_src,box_dst);
837}
838
839
840BOOST_AUTO_TEST_SUITE_END()
841
842#endif
Box
This class represent an N-dimensional box.
Definition Box.hpp:61
Point_orig
Definition of a class Point in plain C++ and boost::vector for testing purpose.
Definition Point_test.hpp:5
Point_test
Test structure used for several test.
Definition Point_test.hpp:106
Point_test::fill
void fill()
fill
Definition Point_test.hpp:373
grid_base
Definition map_grid.hpp:77
grid_key_dx_iterator
Definition grid_key_dx_iterator.hpp:29
grid_key_dx_iterator::get
const grid_key_dx< dim > & get() const
Get the actual key.
Definition grid_key_dx_iterator.hpp:264
grid_key_dx_iterator::isNext
bool isNext()
Check if there is the next element.
Definition grid_key_dx_iterator.hpp:244
grid_key_dx
grid_key_dx is the key to access any element in the grid
Definition grid_key.hpp:19
grid_key_dx::set
__device__ __host__ void set(a v, T...t)
set the Key from a list of numbers
Definition grid_key.hpp:400
grid_smb
Definition grid_smb.hpp:20
grid_zmb
Definition grid_zmb.hpp:26
timer
Class for cpu time benchmarking.
Definition timer.hpp:28
timer::stop
void stop()
Stop the timer.
Definition timer.hpp:119
timer::getcputime
double getcputime()
Return the cpu time.
Definition timer.hpp:142
timer::start
void start()
Start the timer.
Definition timer.hpp:90
timer::getwct
double getwct()
Return the elapsed real time.
Definition timer.hpp:130
aggregate
aggregate of properties, from a list of object if create a struct that follow the OPENFPM native stru...
Definition aggregate.hpp:215
aggregate::type
boost::fusion::vector< list... > type
internal type containing the data
Definition aggregate.hpp:217
copy_encap_vector_fusion
this class is a functor for "for_each" algorithm
Definition copy_fusion_vector.hpp:68
mul
It model an expression expr1 * expr2.
Definition mul.hpp:120