8 #ifndef SRC_VECTOR_VECTOR_DIST_CL_HILB_PERFORMANCE_TESTS_HPP_
9 #define SRC_VECTOR_VECTOR_DIST_CL_HILB_PERFORMANCE_TESTS_HPP_
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 #include "cl_comp_performance_graph.hpp"
17 BOOST_AUTO_TEST_SUITE( celllist_comp_reorder_performance_test )
22 openfpm::vector<
float> r_cutoff {0.004, 0.007, 0.01};
24 size_t k_start = 100000;
54 template<
unsigned int dim>
void cell_list_comp_reorder_random_benchmark(
size_t cl_k_start,
63 cl_time_rand_mean.resize(cl_r_cutoff.
size());
64 cl_time_create_rand_mean.resize(cl_r_cutoff.
size());
65 cl_time_rand_dev.resize(cl_r_cutoff.
size());
66 cl_time_create_rand_dev.resize(cl_r_cutoff.
size());
68 std::string str(
"Testing " + std::to_string(dim) +
"D vector, no order, cell-list");
73 for (
size_t r = 0; r < cl_r_cutoff.
size(); r++ )
78 float r_cut = cl_r_cutoff.get(r);
84 size_t k_count = 1 + log2(k/cl_k_min);
87 for (
size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
89 BOOST_TEST_CHECKPOINT(
"Testing " << dim <<
"D vector with a random cell list k=" << k_int );
91 if (cl_n_particles.
size() < k_count)
92 cl_n_particles.add(k_int);
96 for (
size_t i = 0; i < dim; i++)
105 for (
size_t i = 0; i < dim; i++)
111 vd_initialize<dim>(vd, v_cl, k_int);
113 vd.template ghost_get<0>();
117 auto NN = vd.getCellList(r_cut);
118 double sum_cl_mean = 0;
119 double sum_cl_dev = 0;
122 for (
size_t n = 0 ; n < N_STAT_TEST; n++)
123 measures.add(benchmark_get_celllist(NN,vd,r_cut));
124 standard_deviation(measures,sum_cl_mean,sum_cl_dev);
127 cl_time_create_rand_mean.get(r).add(sum_cl_mean);
128 cl_time_create_rand_dev.get(r).add(sum_cl_dev);
132 double sum_fr_mean = 0;
133 double sum_fr_dev = 0;
136 for (
size_t l = 0 ; l < N_STAT_TEST; l++)
137 measures.add(benchmark_calc_forces<dim>(NN,vd,r_cut));
138 standard_deviation(measures,sum_fr_mean,sum_fr_dev);
140 cl_time_rand_mean.get(r).add(sum_fr_mean);
141 cl_time_rand_dev.get(r).add(sum_fr_dev);
143 if (v_cl.getProcessUnitID() == 0)
144 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;
153 template<
unsigned int dim>
void cell_list_comp_reorder_hilbert_benchmark(
size_t cl_k_start,
162 cl_time_force_mean.resize(cl_r_cutoff.
size());
163 cl_time_create_mean.resize(cl_r_cutoff.
size());
164 cl_time_force_dev.resize(cl_r_cutoff.
size());
165 cl_time_create_dev.resize(cl_r_cutoff.
size());
167 std::string str(
"Testing " + std::to_string(dim) +
"D vector, Hilbert comp reorder, cell list");
172 for (
size_t r = 0; r < cl_r_cutoff.
size(); r++ )
174 Vcluster & v_cl = create_vcluster();
177 float r_cut = cl_r_cutoff.get(r);
183 size_t k_count = 1 + log2(k/cl_k_min);
186 for (
size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
188 BOOST_TEST_CHECKPOINT(
"Testing " << dim <<
"D vector with an Hilbert cell list k=" << k_int );
190 if (cl_n_particles.
size() < k_count)
191 cl_n_particles.add(k_int);
195 for (
size_t i = 0; i < dim; i++)
204 for (
size_t i = 0; i < dim; i++)
210 vd_initialize<dim>(vd, v_cl, k_int);
212 vd.template ghost_get<0>();
216 auto NN = vd.getCellList_hilb(r_cut);
220 double sum_cl_mean = 0;
221 double sum_cl_dev = 0;
222 for (
size_t n = 0 ; n < N_VERLET_TEST; n++)
223 {measures.add(benchmark_get_celllist_hilb(NN,vd,r_cut));}
224 standard_deviation(measures,sum_cl_mean,sum_cl_dev);
226 cl_time_create_mean.get(r).add(sum_cl_mean);
227 cl_time_create_dev.get(r).add(sum_cl_dev);
231 double sum_fr_mean = 0;
232 double sum_fr_dev = 0;
238 for (
size_t l = 0 ; l < N_VERLET_TEST; l++)
239 {measures.add(benchmark_calc_forces_hilb<dim>(NN,vd,r_cut));}
240 standard_deviation(measures,sum_fr_mean,sum_fr_dev);
242 cl_time_force_mean.get(r).add(sum_fr_mean);
243 cl_time_force_dev.get(r).add(sum_fr_dev);
245 if (v_cl.getProcessUnitID() == 0)
246 {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;}
253 BOOST_AUTO_TEST_CASE( vector_dist_celllist_random_test )
256 cell_list_comp_reorder_random_benchmark<3>(k_start,
262 time_create_rand_mean,
263 time_create_rand_dev);
266 cell_list_comp_reorder_random_benchmark<2>(k_start,
272 time_create_rand_2_mean,
273 time_create_rand_2_dev);
276 BOOST_AUTO_TEST_CASE( vector_dist_celllist_hilbert_test )
279 cell_list_comp_reorder_hilbert_benchmark<3>(k_start,
285 time_create_hilb_mean,
286 time_create_hilb_dev);
288 cell_list_comp_reorder_hilbert_benchmark<2>(k_start,
294 time_create_hilb_2_mean,
295 time_create_hilb_2_dev);
301 template<
unsigned int dim>
void cell_list_comp_reorder_report(
GoogleChart & cg,
312 double & warning_level,
315 cl_comp_normal_vs_hilbert_force_time<dim>(cg,
325 cl_comp_normal_vs_hilbert_create_time<dim>(cg,
328 cl_time_create_hilb_mean,
329 cl_time_create_rand_mean,
330 cl_time_create_hilb_dev,
331 cl_time_create_rand_dev,
336 BOOST_AUTO_TEST_CASE(vector_dist_cl_performance_write_report)
340 double warning_level = 0;
344 cell_list_comp_reorder_report<3>(cg,
351 time_create_hilb_mean,
352 time_create_rand_mean,
353 time_create_hilb_dev,
354 time_create_rand_dev,
358 cell_list_comp_reorder_report<2>(cg,
365 time_create_hilb_2_mean,
366 time_create_rand_2_mean,
367 time_create_hilb_2_dev,
368 time_create_rand_2_dev,
374 if (create_vcluster().getProcessUnitID() == 0)
377 pt.put(
"celllist.comp.warning",warning_level);
379 cg.write(
"Celllist_comp_ord.html");
385 BOOST_AUTO_TEST_SUITE_END()
void setHigh(int i, T val)
set the high interval of the box
Implementation of VCluster class.
Small class to produce graph with Google chart in HTML.
void setLow(int i, T val)
set the low interval of the box
This class represent an N-dimensional box.
size_t getProcessingUnits()
Get the total number of processors.