OpenFPM_pdata  1.1.0
Project that contain the implementation of distributed structures
 All Data Structures Namespaces Functions Variables Typedefs Enumerations Friends Pages
grid_dist_performance.hpp
1 /*
2  * grid_dist_performance.hpp
3  *
4  * Created on: Jun 27, 2017
5  * Author: i-bird
6  */
7 
8 #ifndef SRC_GRID_GRID_DIST_PERFORMANCE_HPP_
9 #define SRC_GRID_GRID_DIST_PERFORMANCE_HPP_
10 
11 #include "../../../openfpm_numerics/src/interpolation/interpolation.hpp"
12 #include "Grid/grid_dist_id.hpp"
13 #include "Plot/GoogleChart.hpp"
14 #include "interpolation/mp4_kernel.hpp"
15 
16 #define GRID_ITERATOR_TESTS 30
17 #define GRID_INTERPOLATION_TESTS 30
18 
19 // Vectors to store the data for 3D
20 openfpm::vector<double> time_iterator_normal_mean;
21 openfpm::vector<double> time_iterator_normal_dev;
22 openfpm::vector<double> time_iterator_stencil_mean;
23 openfpm::vector<double> time_iterator_stencil_dev;
24 openfpm::vector<double> time_inte_p2m_mean;
25 openfpm::vector<double> time_inte_m2p_mean;
26 openfpm::vector<double> time_inte_p2m_dev;
27 openfpm::vector<double> time_inte_m2p_dev;
28 openfpm::vector<size_t> nk_grid_st;
29 openfpm::vector<size_t> nk_grid_int;
30 
31 BOOST_AUTO_TEST_SUITE( grid_iterator_performance_test )
32 
33 constexpr int x = 0;
34 constexpr int y = 1;
35 constexpr int z = 2;
36 
41 void grid_interpolation_benchmark(openfpm::vector<size_t> & nk_grid,
42  openfpm::vector<double> & time_interpolation_p2m_mean,
43  openfpm::vector<double> & time_interpolation_m2p_mean,
44  openfpm::vector<double> & time_interpolation_p2m_dev,
45  openfpm::vector<double> & time_interpolation_m2p_dev)
46 {
47  for (size_t k = 0 ; k < nk_grid.size() ; k++)
48  {
49  size_t np = nk_grid.get(k);
50  size_t sz[] = {np,np,np};
51 
52  Ghost<3,long int> gg(3);
53 
54  Box<3,float> domain({0.0,0.0,0.0},{1.0,1.0,1.0});
55 
56  size_t tot_part = np*np*np;
57 
58  grid_dist_id<3, float, aggregate<float>> gd(sz,domain,gg);
59  vector_dist<3,float,aggregate<float>> vd(gd.getDecomposition(),tot_part);
60 
61  // Fill vd with particles
62 
63  auto vd_it = vd.getDomainIterator();
64 
65  while (vd_it.isNext())
66  {
67  auto p = vd_it.get();
68 
69 
70  vd.getPos(p)[0] = ((float)std::rand()) / RAND_MAX;
71  vd.getPos(p)[1] = ((float)std::rand()) / RAND_MAX;
72  vd.getPos(p)[2] = ((float)std::rand()) / RAND_MAX;
73 
74  vd.template getProp<0>(p) = 1.0;
75 
76  ++vd_it;
77  }
78 
79  vd.map();
80 
81  double mean;
82  double dev;
83  openfpm::vector<double> measures;
84  for (size_t j = 0 ; j < GRID_INTERPOLATION_TESTS ; j++)
85  {
86 
87  interpolate<decltype(vd),decltype(gd),mp4_kernel<float>> inte(vd,gd);
88 
89  timer tstl;
90  tstl.start();
91 
92  inte.p2m<0,0>(vd,gd);
93 
94  tstl.stop();
95  measures.add(tstl.getwct());
96  }
97  standard_deviation(measures,mean,dev);
98  time_interpolation_p2m_mean.add(mean);
99  time_interpolation_p2m_dev.add(dev);
100 
101  std::cout << "Time particles to mesh " << time_interpolation_p2m_mean.last() << std::endl;
102 
103  for (size_t j = 0 ; j < GRID_INTERPOLATION_TESTS ; j++)
104  {
105 
106  interpolate<decltype(vd),decltype(gd),mp4_kernel<float>> inte(vd,gd);
107 
108  timer tstl;
109  tstl.start();
110 
111  inte.m2p<0,0>(gd,vd);
112 
113  tstl.stop();
114  measures.add(tstl.getwct());
115  }
116  standard_deviation(measures,mean,dev);
117  time_interpolation_m2p_mean.add(mean);
118  time_interpolation_m2p_dev.add(dev);
119 
120  std::cout << "Time mesh to particles " << time_interpolation_m2p_mean.last() << std::endl;
121  }
122 }
123 
128 double grid_iterator_benchmark_stencil(grid_dist_id<3, float, aggregate<long int>, CartDecomposition<3,float>> & g_dist, double & total)
129 {
130  grid_key_dx<3> star_stencil_3D[7] = {{0,0,0},
131  {-1,0,0},
132  {1,0,0},
133  {0,-1,0},
134  {0,1,0},
135  {0,0,-1},
136  {0,0,1}};
137 
138  timer tstl;
139  tstl.start();
140 
141  auto st_it = g_dist.getDomainIteratorStencil(star_stencil_3D);
142 
143  while (st_it.isNext())
144  {
145 
146  total+= 6*g_dist.template get<0>(st_it.getStencil<0>()) -
147  g_dist.template get<0>(st_it.getStencil<1>()) -
148  g_dist.template get<0>(st_it.getStencil<2>()) -
149  g_dist.template get<0>(st_it.getStencil<3>()) -
150  g_dist.template get<0>(st_it.getStencil<4>()) -
151  g_dist.template get<0>(st_it.getStencil<5>()) -
152  g_dist.template get<0>(st_it.getStencil<6>());
153 
154  ++st_it;
155  }
156 
157  tstl.stop();
158  return tstl.getwct();
159 }
160 
161 double grid_iterator_benchmark_norm(grid_dist_id<3, float, aggregate<long int>, CartDecomposition<3,float>> & g_dist, double & total)
162 {
163  timer tnorm;
164  tnorm.start();
165 
166  auto norm_it = g_dist.getDomainIterator();
167 
168  while (norm_it.isNext())
169  {
170  // center point
171  auto key = norm_it.get();
172 
173  total+= 6*g_dist.template get<0>(key) -
174  g_dist.template get<0>(key.move(x,-1)) -
175  g_dist.template get<0>(key.move(x,1)) -
176  g_dist.template get<0>(key.move(y,-1)) -
177  g_dist.template get<0>(key.move(y,1)) -
178  g_dist.template get<0>(key.move(z,-1)) -
179  g_dist.template get<0>(key.move(z,1));
180 
181  ++norm_it;
182  }
183 
184  tnorm.stop();
185  return tnorm.getwct();
186 }
187 
191 template<unsigned int dim> void grid_iterator_benchmark(openfpm::vector<size_t> & nk_grid,
192  openfpm::vector<double> & time_iterator_normal_mean,
193  openfpm::vector<double> & time_iterator_stencil_mean,
194  openfpm::vector<double> & time_iterator_normal_dev,
195  openfpm::vector<double> & time_iterator_stencil_dev)
196 {
197  std::string str("Testing " + std::to_string(dim) + "D grid iterator stencil and normal");
198  print_test_v(str,0);
199 
200  {
201  //For different grid sizes
202  for (size_t i = 0; i < nk_grid.size(); i++ )
203  {
204  size_t sz[dim];
205 
206  //Number of particles
207  size_t k = nk_grid.get(i);
208 
209 
210  BOOST_TEST_CHECKPOINT( "Testing " << dim << "D vector grid iterator performance k=" << k );
211 
212  Box<dim,float> box;
213 
214  for (size_t i = 0; i < dim; i++)
215  {
216  box.setLow(i,0.0);
217  box.setHigh(i,1.0);
218  sz[i] = k;
219  }
220 
221  Ghost<3,long int> g(1);
222 
223  // Distributed grid with id decomposition
224  grid_dist_id<3, float, aggregate<long int>, CartDecomposition<3,float>> g_dist(sz,box,g);
225 
226  // fill the grid with values
227 
228  auto it = g_dist.getDomainGhostIterator();
229 
230  while (it.isNext())
231  {
232  auto p = it.get();
233  auto gkey = it.getGKey(p);
234 
235  g_dist.template get<0>(p) = gkey.get(0) + gkey.get(1) + gkey.get(2);
236 
237  ++it;
238  }
239 
240  g_dist.ghost_get<0>();
241 
242  double total = 0;
243 
244  double mean;
245  double dev;
246  openfpm::vector<double> measures;
247  for (size_t j = 0 ; j < GRID_ITERATOR_TESTS ; j++)
248  {measures.add(grid_iterator_benchmark_stencil(g_dist,total));}
249  standard_deviation(measures,mean,dev);
250  time_iterator_stencil_mean.add(mean);
251  time_iterator_stencil_dev.add(dev);
252 
254 
255  measures.clear();
256  for (size_t j = 0 ; j < GRID_ITERATOR_TESTS ;j++)
257  {measures.add(grid_iterator_benchmark_norm(g_dist,total));}
258  standard_deviation(measures,mean,dev);
259  time_iterator_normal_mean.add(mean);
260  time_iterator_normal_dev.add(dev);
261 
262  std::cout << "Size: " << nk_grid.get(i) << " " << total << std::endl;
263  }
264  }
265 }
266 
267 
271 template<unsigned int dim>
272 void grid_iterator_performance_write_report(GoogleChart & cg,
273  openfpm::vector<size_t> & nk_grid,
274  openfpm::vector<double> & time_iterator_stencil_mean,
275  openfpm::vector<double> & time_iterator_stencil_dev,
276  openfpm::vector<double> & time_iterator_normal_mean,
277  openfpm::vector<double> & time_iterator_normal_dev)
278 {
279  std::string file_mean(test_dir);
280  std::string file_var(test_dir);
281  file_mean += std::string("/openfpm_pdata/grid_iterator_mean_" + std::to_string(dim) + std::string("_ref"));
282  file_var += std::string("/openfpm_pdata/grid_iterator_dev_" + std::to_string(dim) + std::string("_ref"));
283 
284  std::string file_mean_save = std::string("grid_iterator_mean_" + std::to_string(dim) + std::to_string("_ref"));
285  std::string file_var_save = std::string("grid_iterator_dev_" + std::to_string(dim) + std::to_string("_ref"));
286 
287  openfpm::vector<size_t> xp = nk_grid;
288 
289  openfpm::vector<openfpm::vector<openfpm::vector<double>>> yp_mean;
290  openfpm::vector<openfpm::vector<openfpm::vector<double>>> yp_dev;
291 
292  openfpm::vector<std::string> names;
293  openfpm::vector<std::string> gnames;
294 
295 /* yp_mean.add();
296  yp_dev.add();
297  yp_mean.last().add(time_iterator_stencil_mean);
298  yp_mean.last().add(time_iterator_normal_mean);
299  yp_dev.last().add(time_iterator_stencil_dev);
300  yp_dev.last().add(time_iterator_normal_dev);*/
301 
302  yp_mean.resize(1);
303  yp_dev.resize(1);
304  for (size_t i = 0 ; i < yp_mean.size() ; i++)
305  {
306  yp_mean.get(i).resize(time_iterator_stencil_mean.size());
307  yp_dev.get(i).resize(time_iterator_stencil_dev.size());
308 
309  for (size_t j = 0 ; j < yp_mean.get(i).size() ; j++)
310  {
311  yp_mean.get(i).get(j).resize(2);
312  yp_dev.get(i).get(j).resize(2);
313 
314  yp_mean.get(i).get(j).get(0) = time_iterator_stencil_mean.get(j);
315  yp_mean.get(i).get(j).get(1) = time_iterator_normal_mean.get(j);
316 
317  yp_dev.get(i).get(j).get(0) = time_iterator_stencil_dev.get(j);
318  yp_dev.get(i).get(j).get(1) = time_iterator_normal_dev.get(j);
319  }
320  }
321 
322  gnames.add("Grid iterators performance for stencil");
323  names.add("Stencil specialized iterator");
324  names.add("Normal iterator");
325 
326  std::string y_string = std::string("Time seconds");
327  std::string x_string = std::string("Number of grid poins");
328 
329 
330  StandardPerformanceGraph(file_mean,
331  file_var,
332  file_mean_save,
333  file_var_save,
334  cg,
335  xp,
336  yp_mean,
337  yp_dev,
338  names,
339  gnames,
340  x_string,
341  y_string,
342  true);
343 }
344 
348 template<unsigned int dim>
349 void grid_m2p_performance_write_report(GoogleChart & cg,
350  openfpm::vector<size_t> & nk_grid,
351  openfpm::vector<double> & time_m2p_mean,
352  openfpm::vector<double> & time_m2p_dev)
353 {
354  std::string file_mean(test_dir);
355  std::string file_var(test_dir);
356  file_mean += std::string("/openfpm_pdata/grid_m2p_mean_" + std::to_string(dim) + std::string("_ref"));
357  file_var += std::string("/openfpm_pdata/grid_m2p_dev_" + std::to_string(dim) + std::string("_ref"));
358 
359  std::string file_mean_save = std::string("grid_m2p_mean_" + std::to_string(dim) + std::to_string("_ref"));
360  std::string file_var_save = std::string("grid_m2p_dev_" + std::to_string(dim) + std::to_string("_ref"));
361 
362  openfpm::vector<size_t> xp = nk_grid;
363 
364  openfpm::vector<openfpm::vector<openfpm::vector<double>>> yp_mean;
365  openfpm::vector<openfpm::vector<openfpm::vector<double>>> yp_dev;
366 
367  openfpm::vector<std::string> names;
368  openfpm::vector<std::string> gnames;
369 
370  yp_mean.resize(1);
371  yp_dev.resize(1);
372  for (size_t i = 0 ; i < yp_mean.size() ; i++)
373  {
374  yp_mean.get(i).resize(time_iterator_stencil_mean.size());
375  yp_dev.get(i).resize(time_iterator_stencil_dev.size());
376 
377  for (size_t j = 0 ; j < yp_mean.get(i).size() ; j++)
378  {
379  yp_mean.get(i).get(j).resize(1);
380  yp_dev.get(i).get(j).resize(1);
381 
382  yp_mean.get(i).get(j).get(0) = time_m2p_mean.get(j);
383  yp_dev.get(i).get(j).get(0) = time_m2p_dev.get(j);
384  }
385  }
386 
387  gnames.add("Grid m2p performance");
388  names.add("Mesh to particle performance");
389 
390  std::string y_string = std::string("Time seconds");
391  std::string x_string = std::string("Number of grid poins");
392 
393 
394  StandardPerformanceGraph(file_mean,
395  file_var,
396  file_mean_save,
397  file_var_save,
398  cg,
399  xp,
400  yp_mean,
401  yp_dev,
402  names,
403  gnames,
404  x_string,
405  y_string,
406  true);
407 
408 }
409 
410 
411 
412 BOOST_AUTO_TEST_CASE( grid_interpolation_benchmark_test )
413 {
414  nk_grid_int.add(96);
415  nk_grid_int.add(128);
416  nk_grid_int.add(192);
417 
418  //Benchmark test for 2D and 3D
419  grid_interpolation_benchmark(nk_grid_int,
420  time_inte_p2m_mean,
421  time_inte_m2p_mean,
422  time_inte_p2m_dev,
423  time_inte_m2p_dev);
424 }
425 
426 BOOST_AUTO_TEST_CASE( grid_iterator_benchmark_test )
427 {
428  nk_grid_st.add(96);
429  nk_grid_st.add(128);
430  nk_grid_st.add(192);
431 
432  //Benchmark test for 2D and 3D
433  grid_iterator_benchmark<3>(nk_grid_st,
434  time_iterator_normal_mean,
435  time_iterator_stencil_mean,
436  time_iterator_normal_dev,
437  time_iterator_stencil_dev);
438 }
439 
440 
441 BOOST_AUTO_TEST_CASE(grid_iterator_performance_write_report_final)
442 {
443  GoogleChart cg;
444 
445  //Write report for 2D and 3D
446  grid_iterator_performance_write_report<3>(cg,
447  nk_grid_st,
448  time_iterator_stencil_mean,
449  time_iterator_stencil_dev,
450  time_iterator_normal_mean,
451  time_iterator_normal_dev);
452 
453 
454  grid_m2p_performance_write_report<3>(cg,
455  nk_grid_int,
456  time_inte_m2p_mean,
457  time_inte_m2p_dev);
458 
459  if (create_vcluster().getProcessUnitID() == 0)
460  {
461  addUpdtateTime(cg);
462 
463  cg.write("grid_iterator_performance.html");
464  }
465 }
466 
467 
468 BOOST_AUTO_TEST_SUITE_END()
469 
470 
471 
472 #endif /* SRC_GRID_GRID_DIST_PERFORMANCE_HPP_ */
grid_key_dx
grid_key_dx is the key to access any element in the grid
Definition: grid_key.hpp:18
vector_dist::getPos
auto getPos(vect_dist_key_dx vec_key) -> decltype(v_pos.template get< 0 >(vec_key.getKey()))
Get the position of an element.
Definition: vector_dist.hpp:536
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
timer::getwct
double getwct()
Return the elapsed real time.
Definition: timer.hpp:108
Ghost
Definition: Ghost.hpp:39
GoogleChart
Small class to produce graph with Google chart in HTML.
Definition: GoogleChart.hpp:187
CartDecomposition
This class decompose a space into sub-sub-domains and distribute them across processors.
Definition: CartDecomposition.hpp:132
grid_dist_id
This is a distributed grid.
Definition: grid_dist_id.hpp:69
timer::start
void start()
Start the timer.
Definition: timer.hpp:73
Box::setLow
void setLow(int i, T val)
set the low interval of the box
Definition: Box.hpp:456
vector_dist::map
void map(size_t opt=NONE)
It move all the particles that does not belong to the local processor to the respective processor...
Definition: vector_dist.hpp:1814
key
This class is a trick to indicate the compiler a specific specialization pattern. ...
Definition: memory_c.hpp:201
vector_dist::getDomainIterator
vector_dist_iterator getDomainIterator() const
Get an iterator that traverse the particles in the domain.
Definition: vector_dist.hpp:1715
vector_dist
Distributed vector.
Definition: vector_dist.hpp:202
aggregate
aggregate of properties, from a list of object if create a struct that follow the OPENFPM native stru...
Definition: aggregate.hpp:81
openfpm::vector
Implementation of 1-D std::vector like structure.
Definition: map_vector.hpp:61
timer
Class for cpu time benchmarking.
Definition: timer.hpp:25
interpolate
Main class for interpolation Particle to mest p2m and Mesh to particle m2p.
Definition: interpolation.hpp:503
timer::stop
void stop()
Stop the timer.
Definition: timer.hpp:97