OpenFPM_pdata  4.1.0
Project that contain the implementation of distributed structures
 
Loading...
Searching...
No Matches
cell_list_comp_reorder.hpp
1/*
2 * vector_dist_cl_hilb_performance_tests.hpp
3 *
4 * Created on: May 24, 2016
5 * Author: Yaroslav Zaluzhnyi
6 */
7
8#ifndef SRC_VECTOR_VECTOR_DIST_CL_HILB_PERFORMANCE_TESTS_HPP_
9#define SRC_VECTOR_VECTOR_DIST_CL_HILB_PERFORMANCE_TESTS_HPP_
10
11#include "Vector/vector_dist.hpp"
12#include "data_type/aggregate.hpp"
13#include "Plot/GoogleChart.hpp"
14#include "vector_dist_performance_util.hpp"
15
16// Property tree
17struct report_cell_list_func_tests
18{
19 boost::property_tree::ptree graphs;
20};
21
22report_cell_list_func_tests report_cl_funcs;
23
24BOOST_AUTO_TEST_SUITE( celllist_getCellList_calc_forces_performance_test )
25
26
27
28
29// Cut-off radiuses. Can be put different number of values
30openfpm::vector<float> r_cutoff {0.004, 0.007, 0.01};
31// The starting amount of particles (remember that this number is multiplied by number of processors you use for testing)
32size_t k_start = 100000;
33// The lower threshold for number of particles
34size_t k_min = 15000;
35
37
38// Numbers of particles vector
39openfpm::vector<size_t> n_particles;
40
44template<unsigned int dim> void cell_list_getCellList_calc_force_benchmark(size_t cl_k_start,
45 size_t cl_k_min,
46 openfpm::vector<float> & cl_r_cutoff,
47 openfpm::vector<size_t> & cl_n_particles)
48{
49 std::string str("Testing " + std::to_string(dim) + "D vector, no order, cell-list");
50 print_test_v(str,0);
51
52 {
53 //For different r_cut
54 for (size_t r = 0; r < cl_r_cutoff.size(); r++ )
55 {
56 Vcluster<> & v_cl = create_vcluster();
57
58 //Cut-off radius
59 float r_cut = cl_r_cutoff.get(r);
60
61 //Number of particles
62 size_t k = cl_k_start * v_cl.getProcessingUnits();
63
64 //Counter number for amounts of particles
65 size_t k_count = 1 + log2(k/cl_k_min);
66
67 report_cl_funcs.graphs.put("performance.celllist.getCellList" + std::to_string(dim) + "D(" + std::to_string(r) + ").rcut",r_cut);
68
69 int c = 0;
70
71 //For different number of particles
72 for (size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
73 {
74 BOOST_TEST_CHECKPOINT( "Testing " << dim << "D vector with a random cell list k=" << k_int );
75
76 report_cl_funcs.graphs.put("performance.celllist.getCellList" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").n",k_int);
77 report_cl_funcs.graphs.put("performance.celllist.calc_forces" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").n",k_int);
78
79
80 if (cl_n_particles.size() < k_count)
81 cl_n_particles.add(k_int);
82
83 Box<dim,float> box;
84
85 for (size_t i = 0; i < dim; i++)
86 {
87 box.setLow(i,0.0);
88 box.setHigh(i,1.0);
89 }
90
91 // Boundary conditions
92 size_t bc[dim];
93
94 for (size_t i = 0; i < dim; i++)
95 {bc[i] = PERIODIC;}
96
97 vector_dist<dim,float, aggregate<float[dim]> > vd(k_int,box,bc,Ghost<dim,float>(r_cut));
98
99 // Initialize a dist vector
100 vd_initialize<dim>(vd, v_cl);
101
102 vd.template ghost_get<0>();
103
104 //Get a cell list
105
106 auto NN = vd.getCellList(r_cut);
107 double sum_cl_mean = 0;
108 double sum_cl_dev = 0;
109
110 openfpm::vector<double> measures;
111 for (size_t n = 0 ; n < N_STAT_TEST; n++)
112 {
113 measures.add(benchmark_get_celllist(NN,vd,r_cut));
114 }
115 standard_deviation(measures,sum_cl_mean,sum_cl_dev);
116 //Average total time
117
118 report_cl_funcs.graphs.put("performance.celllist.getCellList" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").mean",sum_cl_mean);
119 report_cl_funcs.graphs.put("performance.celllist.getCellList" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").dev",sum_cl_dev);
120
121 //Calculate forces
122
123 double sum_fr_mean = 0;
124 double sum_fr_dev = 0;
125
126 measures.clear();
127 for (size_t l = 0 ; l < N_STAT_TEST; l++)
128 {measures.add(benchmark_calc_forces<dim>(NN,vd,r_cut));}
129 standard_deviation(measures,sum_fr_mean,sum_fr_dev);
130
131 report_cl_funcs.graphs.put("performance.celllist.calc_forces" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").mean",sum_fr_mean);
132 report_cl_funcs.graphs.put("performance.celllist.calc_forces" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").dev",sum_fr_dev);
133
134 if (v_cl.getProcessUnitID() == 0)
135 std::cout << "Cut-off = " << r_cut << ", Particles = " << k_int << ". Time to create a cell-list: " << sum_cl_mean << " dev: " << sum_cl_dev << " time to calculate forces: " << sum_fr_mean << " dev: " << sum_fr_dev << std::endl;
136
137 c++;
138 }
139 }
140 }
141}
142
146template<unsigned int dim> void cell_list_getCellList_hilb_calc_force_benchmark(size_t cl_k_start,
147 size_t cl_k_min,
148 openfpm::vector<float> & cl_r_cutoff,
149 openfpm::vector<size_t> & cl_n_particles)
150{
151 report_cl_funcs.graphs.put("performance.celllist.dim",std::to_string(dim));
152
153 std::string str("Testing " + std::to_string(dim) + "D vector, Hilbert comp reorder, cell list");
154 print_test_v(str,0);
155
156 {
157 //For different r_cut
158 for (size_t r = 0; r < cl_r_cutoff.size(); r++ )
159 {
160 Vcluster<> & v_cl = create_vcluster();
161
162 //Cut-off radius
163 float r_cut = cl_r_cutoff.get(r);
164
165 report_cl_funcs.graphs.put("performance.celllist.getCellList_hilb" + std::to_string(dim) + "D(" + std::to_string(r) + ").rcut",r_cut);
166
167 //Number of particles
168 size_t k = cl_k_start * v_cl.getProcessingUnits();
169
170 //Counter number for amounts of particles
171 size_t k_count = 1 + log2(k/cl_k_min);
172
173 int c = 0;
174
175 //For different number of particles
176 for (size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
177 {
178 BOOST_TEST_CHECKPOINT( "Testing " << dim << "D vector with an Hilbert cell list k=" << k_int );
179
180 report_cl_funcs.graphs.put("performance.celllist.getCellList_hilb" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").n",k_int);
181 report_cl_funcs.graphs.put("performance.celllist.calc_forces_hilb" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").n",k_int);
182
183 if (cl_n_particles.size() < k_count)
184 cl_n_particles.add(k_int);
185
186 Box<dim,float> box;
187
188 for (size_t i = 0; i < dim; i++)
189 {
190 box.setLow(i,0.0);
191 box.setHigh(i,1.0);
192 }
193
194 // Boundary conditions
195 size_t bc[dim];
196
197 for (size_t i = 0; i < dim; i++)
198 bc[i] = PERIODIC;
199
200 vector_dist<dim,float, aggregate<float[dim]> > vd(k_int,box,bc,Ghost<dim,float>(r_cut));
201
202 // Initialize a dist vector
203 vd_initialize<dim>(vd, v_cl);
204
205 vd.template ghost_get<0>();
206
207 //Get a cell list hilb
208
209 auto NN = vd.getCellList_hilb(r_cut);
210
211 openfpm::vector<double> measures;
212
213 double sum_cl_mean = 0;
214 double sum_cl_dev = 0;
215 for (size_t n = 0 ; n < N_STAT_TEST; n++)
216 {measures.add(benchmark_get_celllist_hilb(NN,vd,r_cut));}
217 standard_deviation(measures,sum_cl_mean,sum_cl_dev);
218 //Average total time
219
220 report_cl_funcs.graphs.put("performance.celllist.getCellList_hilb" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").mean",sum_cl_mean);
221 report_cl_funcs.graphs.put("performance.celllist.getCellList_hilb" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").dev",sum_cl_dev);
222
223 //Calculate forces
224
225 double sum_fr_mean = 0;
226 double sum_fr_dev = 0;
227
228 // Initialize SFC (we are only interested in force calculation)
229 NN.init_SFC();
230
231 measures.clear();
232 for (size_t l = 0 ; l < N_STAT_TEST; l++)
233 {measures.add(benchmark_calc_forces_hilb<dim>(NN,vd,r_cut));}
234 standard_deviation(measures,sum_fr_mean,sum_fr_dev);
235
236 report_cl_funcs.graphs.put("performance.celllist.calc_forces_hilb" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").mean",sum_fr_mean);
237 report_cl_funcs.graphs.put("performance.celllist.calc_forces_hilb" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").dev",sum_fr_dev);
238
239
240 if (v_cl.getProcessUnitID() == 0)
241 {std::cout << "Cut-off = " << r_cut << ", Particles = " << k_int << ". Time to create: " << sum_cl_mean << " dev: " << sum_cl_dev << " time to calculate force: " << sum_fr_mean << " dev: " << sum_fr_dev << std::endl;}
242
243 c++;
244 }
245 }
246 }
247}
248
249
250BOOST_AUTO_TEST_CASE( vector_dist_celllist_random_test )
251{
252 //Benchmark test for 2D and 3D
253 cell_list_getCellList_calc_force_benchmark<3>(k_start,
254 k_min,
255 r_cutoff,
256 n_particles);
257
258
259 cell_list_getCellList_calc_force_benchmark<2>(k_start,
260 k_min,
261 r_cutoff,
262 n_particles);
263}
264
265BOOST_AUTO_TEST_CASE( vector_dist_celllist_hilbert_test )
266{
267 //Benchmark test for 2D and 3D
268 cell_list_getCellList_hilb_calc_force_benchmark<3>(k_start,
269 k_min,
270 r_cutoff,
271 n_particles);
272
273 cell_list_getCellList_hilb_calc_force_benchmark<2>(k_start,
274 k_min,
275 r_cutoff,
276 n_particles);
277}
278
279
280BOOST_AUTO_TEST_CASE(vector_dist_cl_performance_write_report)
281{
282 // Create a graphs
283
284 //For different r_cut
285 for (size_t r = 0; r < r_cutoff.size(); r++ )
286 {
287 report_cl_funcs.graphs.put("graphs.graph(" + std::to_string(r) + ").type","line");
288 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").title","getCellList 3D performance r_cut=" + std::to_string(r_cutoff.get(r)));
289 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").x.title","number of particles");
290 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.title","Time seconds");
291 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(0).source","performance.celllist.getCellList_hilb3D(" + std::to_string(r) + ").npart(#).mean");
292 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").x.data(0).source","performance.celllist.getCellList_hilb3D(" + std::to_string(r) + ").npart(#).n");
293 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(0).title","Cell-list hilbert");
294 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(1).source","performance.celllist.getCellList3D(" + std::to_string(r) + ").npart(#).mean");
295 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").x.data(1).source","performance.celllist.getCellList3D(" + std::to_string(r) + ").npart(#).n");
296 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(1).title","Cell-list normal");
297 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").options.log_y","true");
298 }
299
300 //For different r_cut
301 for (size_t r = 0; r < r_cutoff.size(); r++ )
302 {
303 report_cl_funcs.graphs.put("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").type","line");
304 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").title","calc_force 3D performance (Note hilbert require space filling curve pre-calculation) r_cut=" + std::to_string(r_cutoff.get(r)));
305 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").x.title","number of particles");
306 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.title","Time seconds");
307 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.data(0).source","performance.celllist.calc_forces_hilb3D(" + std::to_string(r) + ").npart(#).mean");
308 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").x.data(0).source","performance.celllist.calc_forces_hilb3D(" + std::to_string(r) + ").npart(#).n");
309 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.data(0).title","Cell-list hilbert");
310 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.data(1).source","performance.celllist.calc_forces3D(" + std::to_string(r) + ").npart(#).mean");
311 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").x.data(1).source","performance.celllist.calc_forces3D(" + std::to_string(r) + ").npart(#).n");
312 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.data(1).title","Cell-list normal");
313 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").options.log_y","true");
314 }
315
316 //For different r_cut
317 for (size_t r = 0; r < r_cutoff.size(); r++ )
318 {
319 report_cl_funcs.graphs.put("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").type","line");
320 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").title","getCellList 2D performance r_cut=" + std::to_string(r_cutoff.get(r)));
321 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").x.title","number of particles");
322 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.title","Time seconds");
323 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.data(0).source","performance.celllist.getCellList_hilb2D(" + std::to_string(r) + ").npart(#).mean");
324 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").x.data(0).source","performance.celllist.getCellList_hilb2D(" + std::to_string(r) + ").npart(#).n");
325 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.data(0).title","Cell-list hilbert");
326 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.data(1).source","performance.celllist.getCellList2D(" + std::to_string(r) + ").npart(#).mean");
327 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").x.data(1).source","performance.celllist.getCellList2D(" + std::to_string(r) + ").npart(#).n");
328 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.data(1).title","Cell-list normal");
329 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").options.log_y","true");
330 }
331
332 //For different r_cut
333 for (size_t r = 0; r < r_cutoff.size(); r++ )
334 {
335 report_cl_funcs.graphs.put("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").type","line");
336 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").title","calc_force 2D performance (Note hilbert require space filling curve pre-calculation) r_cut=" + std::to_string(r_cutoff.get(r)));
337 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").x.title","number of particles");
338 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.title","Time seconds");
339 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.data(0).source","performance.celllist.calc_forces_hilb2D(" + std::to_string(r) + ").npart(#).mean");
340 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").x.data(0).source","performance.celllist.calc_forces_hilb2D(" + std::to_string(r) + ").npart(#).n");
341 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.data(0).title","Cell-list hilbert");
342 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.data(1).source","performance.celllist.calc_forces2D(" + std::to_string(r) + ").npart(#).mean");
343 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").x.data(1).source","performance.celllist.calc_forces2D(" + std::to_string(r) + ").npart(#).n");
344 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.data(1).title","Cell-list normal");
345 report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").options.log_y","true");
346 }
347
348 if (create_vcluster().rank() == 0)
349 {
350 boost::property_tree::xml_writer_settings<std::string> settings(' ', 4);
351 boost::property_tree::write_xml("celllist_performance.xml", report_cl_funcs.graphs,std::locale(),settings);
352
353 GoogleChart cg;
354
355 std::string file_xml_ref(test_dir);
356 file_xml_ref += std::string("/openfpm_pdata/celllist_performance_ref.xml");
357
358 StandardXMLPerformanceGraph("celllist_performance.xml",file_xml_ref,cg);
359
360 addUpdateTime(cg,create_vcluster().size(),"pdata","celllist_performance");
361
362 createCommitFile("pdata");
363
364 cg.write("celllist_performance.html");
365 }
366}
367
368
369
370BOOST_AUTO_TEST_SUITE_END()
371
372#endif /* SRC_VECTOR_VECTOR_DIST_CL_HILB_PERFORMANCE_TESTS_HPP_ */
Box
This class represent an N-dimensional box.
Definition Box.hpp:61
Box::setHigh
__device__ __host__ void setHigh(int i, T val)
set the high interval of the box
Definition Box.hpp:544
Box::setLow
__device__ __host__ void setLow(int i, T val)
set the low interval of the box
Definition Box.hpp:533
GoogleChart
Small class to produce graph with Google chart in HTML.
Definition GoogleChart.hpp:216
GoogleChart::write
void write(std::string file)
It write the graphs on file in html format using Google charts.
Definition GoogleChart.hpp:959
Vcluster_base::getProcessUnitID
size_t getProcessUnitID()
Get the process unit id.
Definition VCluster_base.hpp:535
Vcluster_base::getProcessingUnits
size_t getProcessingUnits()
Get the total number of processors.
Definition VCluster_base.hpp:479
Vcluster
Implementation of VCluster class.
Definition VCluster.hpp:59
openfpm::vector
Implementation of 1-D std::vector like structure.
Definition map_vector.hpp:203
openfpm::vector::size
size_t size()
Stub size.
Definition map_vector.hpp:211
vector_dist
Distributed vector.
Definition vector_dist.hpp:305
report_cell_list_func_tests
Definition cell_list_comp_reorder.hpp:18