cell_list_comp_reorder.hpp 16.4 KB
Newer Older
incardon's avatar
incardon committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * vector_dist_cl_hilb_performance_tests.hpp
 *
 *  Created on: May 24, 2016
 *      Author: Yaroslav Zaluzhnyi
 */

#ifndef SRC_VECTOR_VECTOR_DIST_CL_HILB_PERFORMANCE_TESTS_HPP_
#define SRC_VECTOR_VECTOR_DIST_CL_HILB_PERFORMANCE_TESTS_HPP_

#include "Vector/vector_dist.hpp"
#include "data_type/aggregate.hpp"
#include "Plot/GoogleChart.hpp"
#include "vector_dist_performance_util.hpp"

incardon's avatar
incardon committed
16 17 18 19 20 21 22 23 24 25
// Property tree
struct report_cell_list_func_tests
{
	boost::property_tree::ptree graphs;
};

report_cell_list_func_tests report_cl_funcs;

BOOST_AUTO_TEST_SUITE( celllist_getCellList_calc_forces_performance_test )

incardon's avatar
incardon committed
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

///////////////////// INPUT DATA //////////////////////

// Cut-off radiuses. Can be put different number of values
openfpm::vector<float> r_cutoff {0.004, 0.007, 0.01};
// The starting amount of particles (remember that this number is multiplied by number of processors you use for testing)
size_t k_start = 100000;
// The lower threshold for number of particles
size_t k_min = 15000;

///////////////////////////////////////////////////////

// Numbers of particles vector
openfpm::vector<size_t> n_particles;

incardon's avatar
incardon committed
41 42 43
/*! \brief Function for random cell list test
 *
 */
incardon's avatar
incardon committed
44
template<unsigned int dim> void cell_list_getCellList_calc_force_benchmark(size_t cl_k_start,
incardon's avatar
incardon committed
45 46
		                                                                size_t cl_k_min,
																		openfpm::vector<float> & cl_r_cutoff,
incardon's avatar
incardon committed
47
																		openfpm::vector<size_t> & cl_n_particles)
incardon's avatar
incardon committed
48 49
{
	std::string str("Testing " + std::to_string(dim) + "D vector, no order, cell-list");
50
	print_test_v(str,0);
incardon's avatar
incardon committed
51 52 53 54 55

	{
		//For different r_cut
		for (size_t r = 0; r < cl_r_cutoff.size(); r++ )
		{
incardon's avatar
incardon committed
56
			Vcluster<> & v_cl = create_vcluster();
incardon's avatar
incardon committed
57 58 59 60 61 62 63 64 65 66

			//Cut-off radius
			float r_cut = cl_r_cutoff.get(r);

			//Number of particles
			size_t k = cl_k_start * v_cl.getProcessingUnits();

			//Counter number for amounts of particles
			size_t k_count = 1 + log2(k/cl_k_min);

incardon's avatar
incardon committed
67 68 69 70
			report_cl_funcs.graphs.put("performance.celllist.getCellList" + std::to_string(dim) + "D(" + std::to_string(r) + ").rcut",r_cut);

			int c = 0;

incardon's avatar
incardon committed
71 72 73 74 75
			//For different number of particles
			for (size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
			{
				BOOST_TEST_CHECKPOINT( "Testing " << dim << "D vector with a random cell list k=" << k_int );

incardon's avatar
incardon committed
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);
incardon's avatar
incardon committed
77 78
				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);

incardon's avatar
incardon committed
79

incardon's avatar
incardon committed
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
				if (cl_n_particles.size() < k_count)
					cl_n_particles.add(k_int);

				Box<dim,float> box;

				for (size_t i = 0; i < dim; i++)
				{
					box.setLow(i,0.0);
					box.setHigh(i,1.0);
				}

				// Boundary conditions
				size_t bc[dim];

				for (size_t i = 0; i < dim; i++)
incardon's avatar
incardon committed
95
				{bc[i] = PERIODIC;}
incardon's avatar
incardon committed
96

97
				vector_dist<dim,float, aggregate<float[dim]> > vd(k_int,box,bc,Ghost<dim,float>(r_cut));
incardon's avatar
incardon committed
98 99

				// Initialize a dist vector
incardon's avatar
incardon committed
100
				vd_initialize<dim>(vd, v_cl);
incardon's avatar
incardon committed
101 102 103 104 105 106 107 108 109 110 111

				vd.template ghost_get<0>();

				//Get a cell list

				auto NN = vd.getCellList(r_cut);
				double sum_cl_mean = 0;
				double sum_cl_dev = 0;

				openfpm::vector<double> measures;
				for (size_t n = 0 ; n < N_STAT_TEST; n++)
incardon's avatar
incardon committed
112
				{
incardon's avatar
incardon committed
113
					measures.add(benchmark_get_celllist(NN,vd,r_cut));
incardon's avatar
incardon committed
114
				}
incardon's avatar
incardon committed
115 116 117
				standard_deviation(measures,sum_cl_mean,sum_cl_dev);
				//Average total time

incardon's avatar
incardon committed
118 119 120
				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);
				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);

incardon's avatar
incardon committed
121 122 123 124 125 126 127
				//Calculate forces

				double sum_fr_mean = 0;
				double sum_fr_dev = 0;

				measures.clear();
				for (size_t l = 0 ; l < N_STAT_TEST; l++)
incardon's avatar
incardon committed
128
				{measures.add(benchmark_calc_forces<dim>(NN,vd,r_cut));}
incardon's avatar
incardon committed
129 130
				standard_deviation(measures,sum_fr_mean,sum_fr_dev);

incardon's avatar
incardon committed
131 132 133
				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);
				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);

incardon's avatar
incardon committed
134 135
				if (v_cl.getProcessUnitID() == 0)
					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;
incardon's avatar
incardon committed
136 137

				c++;
incardon's avatar
incardon committed
138 139 140 141 142 143 144 145
			}
		}
	}
}

/*! \brief Function for hilb cell list test
 *
 */
incardon's avatar
incardon committed
146
template<unsigned int dim> void cell_list_getCellList_hilb_calc_force_benchmark(size_t cl_k_start,
incardon's avatar
incardon committed
147 148
		                                                                 size_t cl_k_min,
																		 openfpm::vector<float> & cl_r_cutoff,
incardon's avatar
incardon committed
149
																		 openfpm::vector<size_t> & cl_n_particles)
incardon's avatar
incardon committed
150
{
incardon's avatar
incardon committed
151 152
	report_cl_funcs.graphs.put("performance.celllist.dim",std::to_string(dim));

incardon's avatar
incardon committed
153
	std::string str("Testing " + std::to_string(dim) + "D vector, Hilbert comp reorder, cell list");
154
	print_test_v(str,0);
incardon's avatar
incardon committed
155 156 157 158 159

	{
		//For different r_cut
		for (size_t r = 0; r < cl_r_cutoff.size(); r++ )
		{
incardon's avatar
incardon committed
160
			Vcluster<> & v_cl = create_vcluster();
incardon's avatar
incardon committed
161 162 163 164

			//Cut-off radius
			float r_cut = cl_r_cutoff.get(r);

incardon's avatar
incardon committed
165 166
			report_cl_funcs.graphs.put("performance.celllist.getCellList_hilb" + std::to_string(dim) + "D(" + std::to_string(r) + ").rcut",r_cut);

incardon's avatar
incardon committed
167 168 169 170 171 172
			//Number of particles
			size_t k = cl_k_start * v_cl.getProcessingUnits();

			//Counter number for amounts of particles
			size_t k_count = 1 + log2(k/cl_k_min);

incardon's avatar
incardon committed
173 174
			int c = 0;

incardon's avatar
incardon committed
175 176 177 178 179
			//For different number of particles
			for (size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
			{
				BOOST_TEST_CHECKPOINT( "Testing " << dim << "D vector with an Hilbert cell list k=" << k_int );

incardon's avatar
incardon committed
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);
incardon's avatar
incardon committed
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);
incardon's avatar
incardon committed
182

incardon's avatar
incardon committed
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
				if (cl_n_particles.size() < k_count)
					cl_n_particles.add(k_int);

				Box<dim,float> box;

				for (size_t i = 0; i < dim; i++)
				{
					box.setLow(i,0.0);
					box.setHigh(i,1.0);
				}

				// Boundary conditions
				size_t bc[dim];

				for (size_t i = 0; i < dim; i++)
					bc[i] = PERIODIC;

200
				vector_dist<dim,float, aggregate<float[dim]> > vd(k_int,box,bc,Ghost<dim,float>(r_cut));
incardon's avatar
incardon committed
201 202

				// Initialize a dist vector
incardon's avatar
incardon committed
203
				vd_initialize<dim>(vd, v_cl);
incardon's avatar
incardon committed
204 205 206 207 208 209 210 211 212 213 214

				vd.template ghost_get<0>();

				//Get a cell list hilb

				auto NN = vd.getCellList_hilb(r_cut);

				openfpm::vector<double> measures;

				double sum_cl_mean = 0;
				double sum_cl_dev = 0;
incardon's avatar
incardon committed
215
				for (size_t n = 0 ; n < N_STAT_TEST; n++)
incardon's avatar
incardon committed
216
				{measures.add(benchmark_get_celllist_hilb(NN,vd,r_cut));}
incardon's avatar
incardon committed
217 218 219
				standard_deviation(measures,sum_cl_mean,sum_cl_dev);
				//Average total time

incardon's avatar
incardon committed
220 221 222
				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);
				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);

incardon's avatar
incardon committed
223 224 225 226 227
				//Calculate forces

				double sum_fr_mean = 0;
				double sum_fr_dev = 0;

incardon's avatar
incardon committed
228 229 230
				// Initialize SFC (we are only interested in force calculation)
				NN.init_SFC();

incardon's avatar
incardon committed
231
				measures.clear();
incardon's avatar
incardon committed
232
				for (size_t l = 0 ; l < N_STAT_TEST; l++)
incardon's avatar
incardon committed
233
				{measures.add(benchmark_calc_forces_hilb<dim>(NN,vd,r_cut));}
incardon's avatar
incardon committed
234 235
				standard_deviation(measures,sum_fr_mean,sum_fr_dev);

incardon's avatar
incardon committed
236 237 238 239
				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);
				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);


incardon's avatar
incardon committed
240
				if (v_cl.getProcessUnitID() == 0)
incardon's avatar
incardon committed
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;}
incardon's avatar
incardon committed
242 243

				c++;
incardon's avatar
incardon committed
244 245 246 247 248
			}
		}
	}
}

incardon's avatar
incardon committed
249 250 251 252

BOOST_AUTO_TEST_CASE( vector_dist_celllist_random_test )
{
	//Benchmark test for 2D and 3D
incardon's avatar
incardon committed
253
	cell_list_getCellList_calc_force_benchmark<3>(k_start,
incardon's avatar
incardon committed
254 255
			                                   k_min,
											   r_cutoff,
incardon's avatar
incardon committed
256
											   n_particles);
incardon's avatar
incardon committed
257 258


incardon's avatar
incardon committed
259
	cell_list_getCellList_calc_force_benchmark<2>(k_start,
incardon's avatar
incardon committed
260 261
			                                   k_min,
											   r_cutoff,
incardon's avatar
incardon committed
262
											   n_particles);
incardon's avatar
incardon committed
263 264 265 266 267
}

BOOST_AUTO_TEST_CASE( vector_dist_celllist_hilbert_test )
{
	//Benchmark test for 2D and 3D
incardon's avatar
incardon committed
268
	cell_list_getCellList_hilb_calc_force_benchmark<3>(k_start,
incardon's avatar
incardon committed
269 270
			                                    k_min,
												r_cutoff,
incardon's avatar
incardon committed
271
												n_particles);
incardon's avatar
incardon committed
272

incardon's avatar
incardon committed
273
	cell_list_getCellList_hilb_calc_force_benchmark<2>(k_start,
incardon's avatar
incardon committed
274 275
			                                    k_min,
												r_cutoff,
incardon's avatar
incardon committed
276
												n_particles);
incardon's avatar
incardon committed
277 278
}

incardon's avatar
incardon committed
279

incardon's avatar
incardon committed
280 281
BOOST_AUTO_TEST_CASE(vector_dist_cl_performance_write_report)
{
incardon's avatar
incardon committed
282 283 284
	// Create a graphs

	//For different r_cut
incardon's avatar
incardon committed
285
	for (size_t r = 0; r < r_cutoff.size(); r++ )
incardon's avatar
incardon committed
286 287
	{
		report_cl_funcs.graphs.put("graphs.graph(" + std::to_string(r) + ").type","line");
incardon's avatar
incardon committed
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)));
incardon's avatar
incardon committed
289 290 291 292 293 294 295 296 297 298 299
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").x.title","number of particles");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.title","Time seconds");
		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");
		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");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(0).title","Cell-list hilbert");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(1).source","performance.celllist.getCellList3D(" + std::to_string(r) + ").npart(#).mean");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").x.data(1).source","performance.celllist.getCellList3D(" + std::to_string(r) + ").npart(#).n");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(1).title","Cell-list normal");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r) + ").options.log_y","true");
	}

incardon's avatar
incardon committed
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
	//For different r_cut
	for (size_t r = 0; r < r_cutoff.size(); r++ )
	{
		report_cl_funcs.graphs.put("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").type","line");
		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)));
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").x.title","number of particles");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.title","Time seconds");
		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");
		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");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.data(0).title","Cell-list hilbert");
		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");
		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");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.data(1).title","Cell-list normal");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").options.log_y","true");
	}
incardon's avatar
incardon committed
315

incardon's avatar
incardon committed
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
	//For different r_cut
	for (size_t r = 0; r < r_cutoff.size(); r++ )
	{
		report_cl_funcs.graphs.put("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").type","line");
		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)));
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").x.title","number of particles");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.title","Time seconds");
		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");
		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");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.data(0).title","Cell-list hilbert");
		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");
		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");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.data(1).title","Cell-list normal");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").options.log_y","true");
	}
incardon's avatar
incardon committed
331

incardon's avatar
incardon committed
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
	//For different r_cut
	for (size_t r = 0; r < r_cutoff.size(); r++ )
	{
		report_cl_funcs.graphs.put("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").type","line");
		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)));
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").x.title","number of particles");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.title","Time seconds");
		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");
		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");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.data(0).title","Cell-list hilbert");
		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");
		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");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.data(1).title","Cell-list normal");
		report_cl_funcs.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").options.log_y","true");
	}
incardon's avatar
incardon committed
347

incardon's avatar
incardon committed
348 349 350 351
	if (create_vcluster().rank() == 0)
	{
		boost::property_tree::xml_writer_settings<std::string> settings(' ', 4);
		boost::property_tree::write_xml("celllist_performance.xml", report_cl_funcs.graphs,std::locale(),settings);
incardon's avatar
incardon committed
352

incardon's avatar
incardon committed
353
		GoogleChart cg;
incardon's avatar
incardon committed
354

incardon's avatar
incardon committed
355 356
		std::string file_xml_ref(test_dir);
		file_xml_ref += std::string("/openfpm_pdata/celllist_performance_ref.xml");
incardon's avatar
incardon committed
357

incardon's avatar
incardon committed
358 359 360 361 362 363
		StandardXMLPerformanceGraph("celllist_performance.xml",file_xml_ref,cg);

		addUpdtateTime(cg,create_vcluster().size());

		cg.write("celllist_performance.html");
	}
incardon's avatar
incardon committed
364 365
}

incardon's avatar
incardon committed
366 367


incardon's avatar
incardon committed
368 369 370
BOOST_AUTO_TEST_SUITE_END()

#endif /* SRC_VECTOR_VECTOR_DIST_CL_HILB_PERFORMANCE_TESTS_HPP_ */