OpenFPM_pdata  1.1.0
Project that contain the implementation of distributed structures
 All Data Structures Namespaces Functions Variables Typedefs Enumerations Friends Pages
cell_list_part_reorder.hpp
1 /*
2  * vector_dist_cl_performance_tests.hpp
3  *
4  *
5  * Created on: Mar 22, 2016
6  * Author: Yaroslav Zaluzhnyi
7  */
8 
9 #ifndef SRC_VECTOR_VECTOR_DIST_CL_PERFORMANCE_TESTS_HPP_
10 #define SRC_VECTOR_VECTOR_DIST_CL_PERFORMANCE_TESTS_HPP_
11 
12 #include "Vector/vector_dist.hpp"
13 #include "data_type/aggregate.hpp"
14 #include "Plot/GoogleChart.hpp"
15 #include "cl_part_performance_graph.hpp"
16 #include <functional>
17 
18 
19 BOOST_AUTO_TEST_SUITE( celllist_part_reorder_performance_test )
20 
21 
23 // Cut-off radiuses. Can be put different number of values
24 openfpm::vector<float> r_cutoff {0.004, 0.007, 0.01};
25 // Orders of a curve. Can be put different number of values
26 openfpm::vector<size_t> orders = {1,2,3};
27 // Number of steps of moving the particles
28 size_t n_moving = 8;
29 // Moving distance (step size)
30 double dist = 0.03;
31 // The starting amount of particles (remember that this number is multiplied by number of processors you use for testing)
32 size_t k_start = 100000;
33 // The minimal amount of particles
34 size_t k_min = 15000;
35 
37 
38 // Numbers of particles vector
39 openfpm::vector<size_t> n_particles;
40 // Vectors to store the data for 2D
47 // Vectors to store the data for 3D
54 
55 
59 template<unsigned int dim> void cell_list_part_reorder_random_benchmark(size_t cl_k_start,
60  size_t cl_k_min,
61  openfpm::vector<float> & cl_r_cutoff,
62  openfpm::vector<size_t> & cl_n_particles,
63  openfpm::vector<openfpm::vector<double>> & cl_time_rand_mean,
64  openfpm::vector<openfpm::vector<double>> & cl_time_rand_dev)
65 {
66  cl_time_rand_mean.resize(cl_r_cutoff.size());
67  cl_time_rand_dev.resize(cl_r_cutoff.size());
68 
69  std::string str("Testing " + std::to_string(dim) + "D vector, no-order, Cell-list");
70  print_test_v(str,0);
71 
72  {
73  //For different r_cut
74  for (size_t r = 0; r < cl_r_cutoff.size(); r++ )
75  {
76  Vcluster & v_cl = create_vcluster();
77 
78  //Cut-off radius
79  float r_cut = cl_r_cutoff.get(r);
80 
81  //Number of particles
82  size_t k = cl_k_start * v_cl.getProcessingUnits();
83 
84  //Counter number for amounts of particles
85  size_t k_count = 1 + log2(k/cl_k_min);
86 
87  //For different number of particles
88  for (size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
89  {
90  BOOST_TEST_CHECKPOINT( "Testing " << dim << "D vector without an Hilbert curve reordering k=" << k_int );
91 
92  if (cl_n_particles.size() < k_count)
93  cl_n_particles.add(k_int);
94 
95  Box<dim,float> box;
96 
97  for (size_t i = 0; i < dim; i++)
98  {
99  box.setLow(i,0.0);
100  box.setHigh(i,1.0);
101  }
102 
103  // Boundary conditions
104  size_t bc[dim];
105 
106  for (size_t i = 0; i < dim; i++)
107  bc[i] = PERIODIC;
108 
110 
111  // Initialize a dist vector
112  vd_initialize<dim>(vd, v_cl, k_int);
113 
114  vd.template ghost_get<0>();
115 
116  //Get a cell list
117 
118  auto NN = vd.getCellList(r_cut);
119  double sum_fr_mean = 0;
120  double sum_fr_dev = 0;
121 
122  benchmark_get_celllist(NN,vd,r_cut);
123 
124  //Calculate forces
125  size_t l = 0;
126 
127  openfpm::vector<double> measures;
128  for ( ; l < N_STAT_TEST; l++)
129  measures.add(benchmark_calc_forces<dim>(NN,vd,r_cut));
130  standard_deviation(measures,sum_fr_mean,sum_fr_dev);
131 
132  cl_time_rand_mean.get(r).add(sum_fr_mean);
133  cl_time_rand_dev.get(r).add(sum_fr_dev);
134 
135  if (v_cl.getProcessUnitID() == 0)
136  std::cout << "Cut-off = " << r_cut << ", Particles = " << k_int << " time to calculate forces: " << sum_fr_mean << " dev: " << sum_fr_dev << std::endl;
137  }
138  }
139  }
140 }
141 
142 
146 template<unsigned int dim> void cell_list_part_reorder_hilbert_benchmark(size_t cl_k_start,
147  size_t cl_k_min,
148  size_t n_moving,
149  double dist,
150  openfpm::vector<float> & cl_r_cutoff,
151  openfpm::vector<size_t> & cl_n_particles,
152  openfpm::vector<size_t> &cl_orders,
154  openfpm::vector<openfpm::vector<openfpm::vector<double>>> &cl_time_reorder_hilb_mean,
156  openfpm::vector<openfpm::vector<openfpm::vector<double>>> &cl_time_reorder_hilb_dev)
157 {
158  {
159  cl_time_hilb_mean.resize(cl_r_cutoff.size());
160  cl_time_hilb_dev.resize(cl_r_cutoff.size());
161  for (size_t r = 0; r < cl_time_hilb_mean.size(); r++)
162  {
163  cl_time_hilb_mean.get(r).resize(cl_n_particles.size());
164  cl_time_hilb_dev.get(r).resize(cl_n_particles.size());
165  for (size_t k = 0; k < cl_time_hilb_mean.get(r).size(); k++)
166  {
167  cl_time_hilb_mean.get(r).get(k).resize(cl_orders.size());
168  cl_time_hilb_dev.get(r).get(k).resize(cl_orders.size());
169  }
170  }
171 
172 
173  cl_time_reorder_hilb_mean.resize(cl_r_cutoff.size());
174  cl_time_reorder_hilb_dev.resize(cl_r_cutoff.size());
175  for (size_t r = 0; r < cl_time_reorder_hilb_mean.size(); r++)
176  {
177  cl_time_reorder_hilb_mean.get(r).resize(cl_n_particles.size());
178  cl_time_reorder_hilb_dev.get(r).resize(cl_n_particles.size());
179  for (size_t k = 0; k < cl_time_reorder_hilb_mean.get(r).size(); k++)
180  {
181  cl_time_reorder_hilb_mean.get(r).get(k).resize(cl_orders.size());
182  cl_time_reorder_hilb_dev.get(r).get(k).resize(cl_orders.size());
183  }
184  }
185 
186  // Print test
187  std::string str("Testing " + std::to_string(dim) + "D vector, Hilbert curve reordering, Cell-List");
188  print_test_v(str,0);
189 
190  // For different r_cut
191  for (size_t r = 0; r < cl_r_cutoff.size(); r++ )
192  {
193  Vcluster & v_cl = create_vcluster();
194 
195  // Cut-off radius
196  float r_cut = cl_r_cutoff.get(r);
197 
198  // Number of particles
199  size_t k = cl_k_start * v_cl.getProcessingUnits();
200 
201  //For different curve orders
202  for ( size_t i = 0; i < cl_orders.size(); i++)
203  {
204  size_t m = cl_orders.get(i);
205  size_t part = 0;
206 
207  for (size_t k_int = k ; k_int >= cl_k_min ; k_int/=2, part++ )
208  {
209  BOOST_TEST_CHECKPOINT( "Testing " << dim << "D vector with an Hilbert curve reordering k=" << k_int );
210 
211  Box<dim,float> box;
212 
213  for (size_t i = 0; i < dim; i++)
214  {
215  box.setLow(i,0.0);
216  box.setHigh(i,1.0);
217  }
218 
219  // Boundary conditions
220  size_t bc[dim];
221 
222  for (size_t i = 0; i < dim; i++)
223  bc[i] = PERIODIC;
224 
226 
227  // Initialize a dist vector
228  vd_initialize<dim>(vd, v_cl, k_int);
229 
230  //Reorder a vector
231 
232  double sum_reorder_mean = 0;
233  double sum_reorder_dev = 0;
234 
235  openfpm::vector<double> measures;
236 
237  for (size_t h = 0 ; h < N_STAT_TEST; h++)
238  measures.add(benchmark_reorder(vd,m));
239  standard_deviation(measures,sum_reorder_mean,sum_reorder_dev);
240 
241  //Average reorder time
242  cl_time_reorder_hilb_mean.get(r).get(part).get(i) = sum_reorder_mean;
243  cl_time_reorder_hilb_dev.get(r).get(part).get(i) = sum_reorder_dev;
244 
245  vd.template ghost_get<0>();
246 
247  //Get cell list
248 
249  auto NN = vd.getCellList(r_cut);
250  benchmark_get_celllist(NN,vd,r_cut);
251 
252  //Calculate forces
253 
254  double sum_fr_mean = 0;
255  double sum_fr_dev = 0;
256  measures.clear();
257 
258  for (size_t l = 0 ; l < N_STAT_TEST ; l++)
259  measures.add(benchmark_calc_forces<dim>(NN,vd,r_cut));
260  standard_deviation(measures,sum_fr_mean,sum_fr_dev);
261 
262  cl_time_hilb_mean.get(r).get(part).get(i) = sum_fr_mean;
263  cl_time_hilb_dev.get(r).get(part).get(i) = sum_fr_dev;
264 
265 
266  if (v_cl.getProcessUnitID() == 0)
267  std::cout << "Cut-off = " << r_cut << ", Particles = " << k_int << ". Time to reorder: " << sum_reorder_mean << " dev: " << sum_reorder_dev << " time calculate forces: " << sum_fr_mean << " dev: " << sum_fr_dev << std::endl;
268  }
269  }
270  }
271  }
272 }
273 
274 
275 
279 template<unsigned int dim> void cell_list_part_reorder_report(GoogleChart & cg,
280  size_t n_moving,
281  openfpm::vector<float> & cl_r_cutoff,
282  openfpm::vector<size_t> & cl_n_particles,
283  openfpm::vector<size_t> cl_orders,
285  openfpm::vector<openfpm::vector<double>> cl_time_rand_mean,
288  openfpm::vector<openfpm::vector<double>> cl_time_rand_dev,
290 {
292 
293  for (size_t i = 0; i < cl_n_particles.size() ; i++)
294  x.add(cl_n_particles.get(i));
295 
296  // Speedup graphs data
297 
298  cl_part_time<dim>(cg,
299  cl_n_particles,
300  cl_r_cutoff,
301  cl_orders,
302  cl_time_hilb_mean,
303  cl_time_rand_mean,
304  cl_time_hilb_dev,
305  cl_time_rand_dev);
306 
307  cl_part_reorder_time<dim>(cg,
308  cl_n_particles,
309  cl_r_cutoff,
310  cl_orders,
311  cl_time_reorder_mean,
312  cl_time_reorder_dev);
313 }
314 
315 
316 
317 BOOST_AUTO_TEST_CASE( vector_dist_cl_random_test )
318 {
319  //Benchmark test for 2D and 3D
320  cell_list_part_reorder_random_benchmark<3>(k_start,k_min,r_cutoff,n_particles,time_rand_mean,time_rand_dev);
321  cell_list_part_reorder_random_benchmark<2>(k_start,k_min,r_cutoff,n_particles,time_rand_2_mean,time_rand_2_dev);
322 }
323 
324 BOOST_AUTO_TEST_CASE( vector_dist_cl_hilbert_test )
325 {
326  //Benchmark test for 2D and 3D
327  cell_list_part_reorder_hilbert_benchmark<3>(k_start,
328  k_min,
329  n_moving,
330  dist,
331  r_cutoff,
332  n_particles,
333  orders,
334  time_hilb_mean,
335  time_reorder_mean,
336  time_hilb_dev,
337  time_reorder_dev);
338 
339  cell_list_part_reorder_hilbert_benchmark<2>(k_start,
340  k_min,
341  n_moving,
342  dist,
343  r_cutoff,
344  n_particles,
345  orders,
346  time_hilb_2_mean,
347  time_reorder_2_mean,
348  time_hilb_2_dev,
349  time_reorder_2_dev);
350 }
351 
352 BOOST_AUTO_TEST_CASE(vector_dist_cl_performance_write_report)
353 {
354  GoogleChart cg;
355 
356  //Write report for 2D and 3D
357  cell_list_part_reorder_report<3>(cg,
358  n_moving,
359  r_cutoff,
360  n_particles,
361  orders,
362  time_hilb_mean,
363  time_rand_mean,
364  time_reorder_mean,
365  time_hilb_dev,
366  time_rand_dev,
367  time_reorder_dev);
368 
369  cell_list_part_reorder_report<2>(cg,
370  n_moving,
371  r_cutoff,
372  n_particles,
373  orders,
374  time_hilb_2_mean,
375  time_rand_2_mean,
376  time_reorder_2_mean,
377  time_hilb_2_dev,
378  time_rand_2_dev,
379  time_reorder_2_dev);
380 
381  addUpdtateTime(cg);
382 
383  if (create_vcluster().getProcessUnitID() == 0)
384  cg.write("Celllist_part_ord.html");
385 }
386 
387 BOOST_AUTO_TEST_SUITE_END()
388 
389 #endif /* SRC_VECTOR_VECTOR_DIST_CL_PERFORMANCE_TESTS_HPP_ */
void setHigh(int i, T val)
set the high interval of the box
Definition: Box.hpp:467
size_t size()
Stub size.
Definition: map_vector.hpp:70
Definition: Ghost.hpp:39
Implementation of VCluster class.
Definition: VCluster.hpp:36
Small class to produce graph with Google chart in HTML.
void setLow(int i, T val)
set the low interval of the box
Definition: Box.hpp:456
This class represent an N-dimensional box.
Definition: Box.hpp:56
Distributed vector.
size_t getProcessingUnits()
Get the total number of processors.