1 | /* |
2 | * vector_dist_dlb_test.hpp |
3 | * |
4 | * Created on: Feb 21, 2017 |
5 | * Author: i-bird |
6 | */ |
7 | |
8 | #ifndef SRC_VECTOR_VECTOR_DIST_DLB_TEST_HPP_ |
9 | #define SRC_VECTOR_VECTOR_DIST_DLB_TEST_HPP_ |
10 | |
11 | #include "DLB/LB_Model.hpp" |
12 | #include "Vector/vector_dist.hpp" |
13 | |
14 | BOOST_AUTO_TEST_SUITE( vector_dist_dlb_test ) |
15 | |
16 | template<typename vector_type> |
17 | void mp_test_template(vector_type & vd0, vector_type & vd1, vector_type & vd2, vector_type & vd3) |
18 | { |
19 | Vcluster<> & v_cl = create_vcluster(); |
20 | |
21 | // Only processor 0 initialy add particles on a corner of a domain |
22 | |
23 | if (v_cl.getProcessUnitID() == 0) |
24 | { |
25 | for(size_t i = 0 ; i < 50000 ; i++) |
26 | { |
27 | vd0.add(); |
28 | vd1.add(); |
29 | vd2.add(); |
30 | vd3.add(); |
31 | |
32 | // coverty[dont_call] |
33 | vd0.getLastPos()[0] = ((float)rand())/RAND_MAX * 0.3; |
34 | // coverty[dont_call] |
35 | vd0.getLastPos()[1] = ((float)rand())/RAND_MAX * 0.3; |
36 | // coverty[dont_call] |
37 | vd0.getLastPos()[2] = ((float)rand())/RAND_MAX * 0.3; |
38 | |
39 | // coverty[dont_call] |
40 | vd1.getLastPos()[0] = ((float)rand())/RAND_MAX * 0.3 + 0.1; |
41 | // coverty[dont_call] |
42 | vd1.getLastPos()[1] = ((float)rand())/RAND_MAX * 0.3 + 0.1; |
43 | // coverty[dont_call] |
44 | vd1.getLastPos()[2] = ((float)rand())/RAND_MAX * 0.3 + 0.1; |
45 | |
46 | // coverty[dont_call] |
47 | vd2.getLastPos()[0] = ((float)rand())/RAND_MAX * 0.3 + 0.2; |
48 | // coverty[dont_call] |
49 | vd2.getLastPos()[1] = ((float)rand())/RAND_MAX * 0.3 + 0.2; |
50 | // coverty[dont_call] |
51 | vd2.getLastPos()[2] = ((float)rand())/RAND_MAX * 0.3 + 0.2; |
52 | |
53 | // coverty[dont_call] |
54 | vd3.getLastPos()[0] = ((float)rand())/RAND_MAX * 0.3 + 0.3; |
55 | // coverty[dont_call] |
56 | vd3.getLastPos()[1] = ((float)rand())/RAND_MAX * 0.3 + 0.3; |
57 | // coverty[dont_call] |
58 | vd3.getLastPos()[2] = ((float)rand())/RAND_MAX * 0.3 + 0.3; |
59 | } |
60 | } |
61 | |
62 | vd0.map(); |
63 | vd0.template ghost_get<>(); |
64 | vd1.map(); |
65 | vd1.template ghost_get<>(); |
66 | vd2.map(); |
67 | vd2.template ghost_get<>(); |
68 | vd3.map(); |
69 | vd3.template ghost_get<>(); |
70 | |
71 | ModelSquare md; |
72 | md.factor = 1; |
73 | vd0.initializeComputationCosts(); |
74 | vd0.addComputationCosts(vd0,md); |
75 | vd0.addComputationCosts(vd1,md); |
76 | vd0.addComputationCosts(vd2,md); |
77 | vd0.addComputationCosts(vd3,md); |
78 | vd0.finalizeComputationCosts(); |
79 | |
80 | vd0.getDecomposition().decompose(); |
81 | |
82 | // Copy the decomposition back to the other |
83 | vd1.getDecomposition() = vd0.getDecomposition(); |
84 | vd2.getDecomposition() = vd0.getDecomposition(); |
85 | vd3.getDecomposition() = vd0.getDecomposition(); |
86 | |
87 | vd0.map(); |
88 | vd1.map(); |
89 | vd2.map(); |
90 | vd3.map(); |
91 | |
92 | vd0.initializeComputationCosts(); |
93 | vd0.addComputationCosts(vd0,md); |
94 | vd0.addComputationCosts(vd1,md); |
95 | vd0.addComputationCosts(vd2,md); |
96 | vd0.addComputationCosts(vd3,md); |
97 | vd0.finalizeComputationCosts(); |
98 | |
99 | openfpm::vector<size_t> loads; |
100 | size_t load = vd0.getDecomposition().getDistribution().getProcessorLoad(); |
101 | v_cl.allGather(load,loads); |
102 | v_cl.execute(); |
103 | |
104 | for (size_t i = 0 ; i < loads.size() ; i++) |
105 | { |
106 | float load_f = load; |
107 | float load_fc = loads.get(i); |
108 | |
109 | BOOST_REQUIRE_CLOSE(load_f,load_fc,7.0); |
110 | } |
111 | |
112 | Point<3,float> v({1.0,1.0,1.0}); |
113 | |
114 | for (size_t i = 0 ; i < 25 ; i++) |
115 | { |
116 | // move the particles by 0.1 |
117 | |
118 | { |
119 | auto it = vd0.getDomainIterator(); |
120 | |
121 | while (it.isNext()) |
122 | { |
123 | auto p = it.get(); |
124 | |
125 | vd0.getPos(p)[0] += v.get(0) * 0.09; |
126 | vd0.getPos(p)[1] += v.get(1) * 0.09; |
127 | vd0.getPos(p)[2] += v.get(2) * 0.09; |
128 | |
129 | ++it; |
130 | } |
131 | } |
132 | |
133 | { |
134 | auto it = vd1.getDomainIterator(); |
135 | while (it.isNext()) |
136 | { |
137 | auto p = it.get(); |
138 | |
139 | vd1.getPos(p)[0] += v.get(0) * 0.06; |
140 | vd1.getPos(p)[1] += v.get(1) * 0.06; |
141 | vd1.getPos(p)[2] += v.get(2) * 0.06; |
142 | |
143 | ++it; |
144 | } |
145 | } |
146 | |
147 | { |
148 | auto it = vd2.getDomainIterator(); |
149 | while (it.isNext()) |
150 | { |
151 | auto p = it.get(); |
152 | |
153 | vd2.getPos(p)[0] += v.get(0) * 0.06; |
154 | vd2.getPos(p)[1] += v.get(1) * 0.06; |
155 | vd2.getPos(p)[2] += v.get(2) * 0.06; |
156 | |
157 | ++it; |
158 | } |
159 | } |
160 | |
161 | { |
162 | auto it = vd3.getDomainIterator(); |
163 | while (it.isNext()) |
164 | { |
165 | auto p = it.get(); |
166 | |
167 | vd3.getPos(p)[0] += v.get(0) * 0.06; |
168 | vd3.getPos(p)[1] += v.get(1) * 0.06; |
169 | vd3.getPos(p)[2] += v.get(2) * 0.06; |
170 | |
171 | ++it; |
172 | } |
173 | } |
174 | |
175 | vd0.map(); |
176 | vd1.map(); |
177 | vd2.map(); |
178 | vd3.map(); |
179 | |
180 | ModelSquare md; |
181 | vd0.initializeComputationCosts(); |
182 | vd0.addComputationCosts(vd0,md); |
183 | vd0.addComputationCosts(vd1,md); |
184 | vd0.addComputationCosts(vd2,md); |
185 | vd0.addComputationCosts(vd3,md); |
186 | vd0.finalizeComputationCosts(); |
187 | |
188 | vd0.getDecomposition().redecompose(200); |
189 | |
190 | // Copy the decomposition back to the other |
191 | vd1.getDecomposition() = vd0.getDecomposition(); |
192 | vd2.getDecomposition() = vd0.getDecomposition(); |
193 | vd3.getDecomposition() = vd0.getDecomposition(); |
194 | vd0.map(); |
195 | vd1.map(); |
196 | vd2.map(); |
197 | vd3.map(); |
198 | |
199 | vd0.template ghost_get<>(); |
200 | vd1.template ghost_get<>(); |
201 | vd2.template ghost_get<>(); |
202 | vd3.template ghost_get<>(); |
203 | |
204 | vd0.initializeComputationCosts(); |
205 | vd0.addComputationCosts(vd0,md); |
206 | vd0.addComputationCosts(vd1,md); |
207 | vd0.addComputationCosts(vd2,md); |
208 | vd0.addComputationCosts(vd3,md); |
209 | vd0.finalizeComputationCosts(); |
210 | |
211 | openfpm::vector<size_t> loads; |
212 | size_t load = vd0.getDecomposition().getDistribution().getProcessorLoad(); |
213 | v_cl.allGather(load,loads); |
214 | v_cl.execute(); |
215 | |
216 | for (size_t i = 0 ; i < loads.size() ; i++) |
217 | { |
218 | float load_f = load; |
219 | float load_fc = loads.get(i); |
220 | |
221 | BOOST_REQUIRE_CLOSE(load_f,load_fc,10.0); |
222 | } |
223 | } |
224 | } |
225 | |
226 | template<typename vector_type> void test_dlb_vector() |
227 | { |
228 | Vcluster<> & v_cl = create_vcluster(); |
229 | |
230 | if (v_cl.getProcessingUnits() > 8) |
231 | return; |
232 | |
233 | Box<3,double> domain({0.0,0.0,0.0},{1.0,1.0,1.0}); |
234 | Ghost<3,double> g(0.1); |
235 | size_t bc[3] = {PERIODIC,PERIODIC,PERIODIC}; |
236 | |
237 | vector_type vd(0,domain,bc,g,DEC_GRAN(2048)); |
238 | |
239 | // Only processor 0 initialy add particles on a corner of a domain |
240 | |
241 | if (v_cl.getProcessUnitID() == 0) |
242 | { |
243 | for(size_t i = 0 ; i < 50000 ; i++) |
244 | { |
245 | vd.add(); |
246 | |
247 | vd.getLastPos()[0] = ((double)rand())/RAND_MAX * 0.3; |
248 | vd.getLastPos()[1] = ((double)rand())/RAND_MAX * 0.3; |
249 | vd.getLastPos()[2] = ((double)rand())/RAND_MAX * 0.3; |
250 | } |
251 | } |
252 | |
253 | vd.map(); |
254 | vd.template ghost_get<>(); |
255 | |
256 | // Get the neighborhood of each particles |
257 | |
258 | auto VV = vd.getVerlet(0.01); |
259 | |
260 | // store the number of neighborhood for each particles |
261 | |
262 | auto it = vd.getDomainIterator(); |
263 | |
264 | while (it.isNext()) |
265 | { |
266 | auto p = it.get(); |
267 | |
268 | vd.template getProp<0>(p) = VV.getNNPart(p.getKey()); |
269 | |
270 | ++it; |
271 | } |
272 | |
273 | ModelSquare md; |
274 | md.factor = 10; |
275 | vd.map(); |
276 | |
277 | vd.addComputationCosts(md); |
278 | vd.getDecomposition().decompose(); |
279 | vd.map(); |
280 | |
281 | vd.addComputationCosts(md); |
282 | |
283 | openfpm::vector<size_t> loads; |
284 | size_t load = vd.getDecomposition().getDistribution().getProcessorLoad(); |
285 | v_cl.allGather(load,loads); |
286 | v_cl.execute(); |
287 | |
288 | for (size_t i = 0 ; i < loads.size() ; i++) |
289 | { |
290 | double load_f = load; |
291 | double load_fc = loads.get(i); |
292 | |
293 | BOOST_REQUIRE_CLOSE(load_f,load_fc,7.0); |
294 | } |
295 | |
296 | BOOST_REQUIRE(vd.size_local() != 0); |
297 | |
298 | Point<3,double> v({1.0,1.0,1.0}); |
299 | |
300 | for (size_t i = 0 ; i < 25 ; i++) |
301 | { |
302 | // move the particles by 0.1 |
303 | |
304 | auto it = vd.getDomainIterator(); |
305 | |
306 | while (it.isNext()) |
307 | { |
308 | auto p = it.get(); |
309 | |
310 | vd.getPos(p)[0] += v.get(0) * 0.09; |
311 | vd.getPos(p)[1] += v.get(1) * 0.09; |
312 | vd.getPos(p)[2] += v.get(2) * 0.09; |
313 | |
314 | ++it; |
315 | } |
316 | |
317 | vd.map(); |
318 | |
319 | vd.template ghost_get<>(); |
320 | |
321 | auto VV2 = vd.getVerlet(0.01); |
322 | |
323 | auto it2 = vd.getDomainIterator(); |
324 | |
325 | bool match = true; |
326 | while (it2.isNext()) |
327 | { |
328 | auto p = it2.get(); |
329 | |
330 | match &= vd.template getProp<0>(p) == VV2.getNNPart(p.getKey()); |
331 | |
332 | ++it2; |
333 | } |
334 | |
335 | BOOST_REQUIRE_EQUAL(match,true); |
336 | |
337 | ModelSquare md; |
338 | vd.addComputationCosts(md); |
339 | vd.getDecomposition().redecompose(200); |
340 | vd.map(); |
341 | |
342 | BOOST_REQUIRE(vd.size_local() != 0); |
343 | |
344 | vd.template ghost_get<>(); |
345 | |
346 | vd.addComputationCosts(md); |
347 | |
348 | openfpm::vector<size_t> loads; |
349 | size_t load = vd.getDecomposition().getDistribution().getProcessorLoad(); |
350 | v_cl.allGather(load,loads); |
351 | v_cl.execute(); |
352 | |
353 | for (size_t i = 0 ; i < loads.size() ; i++) |
354 | { |
355 | double load_f = load; |
356 | double load_fc = loads.get(i); |
357 | |
358 | BOOST_REQUIRE_CLOSE(load_f,load_fc,10.0); |
359 | } |
360 | } |
361 | } |
362 | |
363 | |
364 | template<typename vector_type> void test_dlb_multi_phase_vector() |
365 | { |
366 | Vcluster<> & v_cl = create_vcluster(); |
367 | |
368 | if (v_cl.getProcessingUnits() > 8) |
369 | return; |
370 | |
371 | Box<3,float> domain({0.0,0.0,0.0},{1.0,1.0,1.0}); |
372 | Ghost<3,float> g(0.1); |
373 | size_t bc[3] = {PERIODIC,PERIODIC,PERIODIC}; |
374 | |
375 | vector_type vd0(0,domain,bc,g,DEC_GRAN(2048)); |
376 | vector_type vd1(0,domain,bc,g,DEC_GRAN(2048)); |
377 | vector_type vd2(0,domain,bc,g,DEC_GRAN(2048)); |
378 | vector_type vd3(0,domain,bc,g,DEC_GRAN(2048)); |
379 | |
380 | mp_test_template(vd0,vd1,vd2,vd3); |
381 | } |
382 | |
383 | |
384 | |
385 | template<typename vector_type> void test_dlb_multi_phase_v_vector() |
386 | { |
387 | Vcluster<> & v_cl = create_vcluster(); |
388 | |
389 | if (v_cl.getProcessingUnits() > 8) |
390 | return; |
391 | |
392 | Box<3,float> domain({0.0,0.0,0.0},{1.0,1.0,1.0}); |
393 | Ghost<3,float> g(0.1); |
394 | size_t bc[3] = {PERIODIC,PERIODIC,PERIODIC}; |
395 | |
396 | openfpm::vector<vector_type> v_phases; |
397 | { |
398 | vector_type vd0(0,domain,bc,g,DEC_GRAN(2048)); |
399 | v_phases.add(vd0); |
400 | v_phases.add(vector_type(vd0.getDecomposition(),0)); |
401 | v_phases.add(vector_type(vd0.getDecomposition(),0)); |
402 | v_phases.add(vector_type(vd0.getDecomposition(),0)); |
403 | } |
404 | |
405 | auto & vd0 = v_phases.get(0); |
406 | auto & vd1 = v_phases.get(1); |
407 | auto & vd2 = v_phases.get(2); |
408 | auto & vd3 = v_phases.get(3); |
409 | |
410 | mp_test_template(vd0,vd1,vd2,vd3); |
411 | } |
412 | |
413 | BOOST_AUTO_TEST_CASE( vector_dist_dlb ) |
414 | { |
415 | test_dlb_vector<vector_dist<3,double,aggregate<double>>>(); |
416 | } |
417 | |
418 | BOOST_AUTO_TEST_CASE( vector_dist_dlb_multi_phase_test_part ) |
419 | { |
420 | test_dlb_multi_phase_vector<vector_dist<3,float,aggregate<float>>>(); |
421 | } |
422 | |
423 | BOOST_AUTO_TEST_CASE( vector_dist_dlb_multi_phase_v_test_part ) |
424 | { |
425 | test_dlb_multi_phase_v_vector<vector_dist<3,float,aggregate<float>>>(); |
426 | } |
427 | |
428 | BOOST_AUTO_TEST_CASE( vector_dist_dlb_metis_test_part ) |
429 | { |
430 | test_dlb_vector<vector_dist<3, |
431 | double, |
432 | aggregate<double>, |
433 | CartDecomposition<3,double,HeapMemory,memory_traits_lin,MetisDistribution<3,double>>>>(); |
434 | } |
435 | |
436 | BOOST_AUTO_TEST_SUITE_END() |
437 | |
438 | #endif /* SRC_VECTOR_VECTOR_DIST_DLB_TEST_HPP_ */ |
439 | |