1 /*
2 * Distributed under the OSI-approved Apache License, Version 2.0. See
3 * accompanying file Copyright.txt for details.
4 */
5 #include <cmath>
6 #include <cstdint>
7 #include <cstring>
8
9 #include <iostream>
10 #include <limits>
11 #include <stdexcept>
12
13 #include <adios2.h>
14 #include <adios2/common/ADIOSTypes.h>
15 #include <adios2/helper/adiosMath.h>
16
17 #include <gtest/gtest.h>
18
19 template <typename T>
printVector(const std::vector<T> & v)20 void printVector(const std::vector<T> &v)
21 {
22 const size_t ndim = v.size();
23 std::cout << "{";
24 for (int d = 0; d < ndim; ++d)
25 {
26 std::cout << v[d];
27 if (d < ndim - 1)
28 {
29 std::cout << ", ";
30 }
31 if (d > 0 && !(d % 20))
32 {
33 std::cout << "\n ";
34 }
35 }
36 std::cout << "}";
37 }
38
printTestInfo(const adios2::Dims & count,const size_t blockSize,const size_t sourceLine)39 void printTestInfo(const adios2::Dims &count, const size_t blockSize,
40 const size_t sourceLine)
41 {
42 const size_t ndim = count.size();
43 std::cout << "\nTest " << ndim << "-D array ";
44 printVector(count);
45 std::cout << " divide by blockSize " << blockSize << " at line "
46 << sourceLine << std::endl;
47 }
48
printBlockDivisionInfo(const adios2::helper::BlockDivisionInfo & info)49 void printBlockDivisionInfo(const adios2::helper::BlockDivisionInfo &info)
50 {
51 std::cout << " nblocks = " << info.NBlocks; // << std::endl;
52 std::cout << " subblockSize = " << info.SubBlockSize; // << std::endl;
53 std::cout << " div = ";
54 printVector(info.Div);
55 // std::cout << std::endl;
56 std::cout << " rem = ";
57 printVector(info.Rem);
58 // std::cout << std::endl;
59 std::cout << " reverseDivProduct = ";
60 printVector(info.ReverseDivProduct);
61 std::cout << std::endl;
62 }
63
printBlock(const adios2::Box<adios2::Dims> & block,const int blockID)64 void printBlock(const adios2::Box<adios2::Dims> &block, const int blockID)
65 {
66 std::cout << " block " << blockID << " start = ";
67 printVector(block.first);
68 std::cout << " count = ";
69 printVector(block.second);
70 std::cout << std::endl;
71 }
72
73 template <typename T>
printMinMax(const std::vector<T> & expected_minmax,const T & expected_bmin,const T & expected_bmax)74 void printMinMax(const std::vector<T> &expected_minmax, const T &expected_bmin,
75 const T &expected_bmax)
76 {
77 std::cout << " expected bmin = " << expected_bmin
78 << " bmax = " << expected_bmax;
79 std::cout << " min-max = \n ";
80 printVector(expected_minmax);
81 std::cout << std::endl;
82 }
83
printBlock(const adios2::Box<adios2::Dims> & block,const int blockID,const std::vector<uint16_t> & expected_start,const std::vector<uint16_t> & expected_count)84 void printBlock(const adios2::Box<adios2::Dims> &block, const int blockID,
85 const std::vector<uint16_t> &expected_start,
86 const std::vector<uint16_t> &expected_count)
87 {
88 std::cout << " block " << blockID << " start = ";
89 printVector(block.first);
90 std::cout << " count = ";
91 printVector(block.second);
92 std::cout << " expected start = ";
93 printVector(expected_start);
94 std::cout << " count = ";
95 printVector(expected_count);
96 std::cout << std::endl;
97 }
98
assert_block(const adios2::Box<adios2::Dims> & block,const int blockID,const std::vector<uint16_t> & expected_start,const std::vector<uint16_t> & expected_count)99 void assert_block(const adios2::Box<adios2::Dims> &block, const int blockID,
100 const std::vector<uint16_t> &expected_start,
101 const std::vector<uint16_t> &expected_count)
102 {
103 printBlock(block, blockID, expected_start, expected_count);
104 const adios2::Dims &block_start = block.first;
105 const adios2::Dims &block_count = block.second;
106 ASSERT_EQ(block_start.size(), expected_start.size());
107 const size_t nstart = expected_start.size();
108 for (int d = 0; d < nstart; ++d)
109 {
110 ASSERT_EQ(block_start[d], expected_start[d]);
111 }
112 ASSERT_EQ(block_count.size(), expected_count.size());
113 const size_t ncount = expected_count.size();
114 for (int d = 0; d < nstart; ++d)
115 {
116 ASSERT_EQ(block_count[d], expected_count[d]);
117 }
118 }
119
120 template <typename T>
assert_minmax(const size_t nBlocks,const T & bmin,const T & bmax,const std::vector<T> & minmax,const T & expected_bmin,const T & expected_bmax,const std::vector<T> & expected_minmax)121 void assert_minmax(const size_t nBlocks, const T &bmin, const T &bmax,
122 const std::vector<T> &minmax, const T &expected_bmin,
123 const T &expected_bmax,
124 const std::vector<T> &expected_minmax)
125 {
126 printMinMax(expected_minmax, expected_bmin, expected_bmax);
127 ASSERT_EQ(bmin, expected_bmin);
128 ASSERT_EQ(bmax, expected_bmax);
129
130 const size_t nMinMax = expected_minmax.size();
131 ASSERT_EQ(nMinMax, 2 * nBlocks);
132 for (int i = 0; i < nMinMax; ++i)
133 {
134 ASSERT_EQ(minmax[i], expected_minmax[i]);
135 }
136 }
137
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_1D_100)138 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_1D_100)
139 {
140 std::vector<int> data(100);
141 for (int i = 0; i < data.size(); ++i)
142 {
143 data[i] = i;
144 }
145 size_t blockSize;
146 adios2::Dims count(1, data.size());
147 adios2::Box<adios2::Dims> block;
148 // int blockID;
149 std::vector<int> MinMaxs;
150 int Min, Max;
151
152 {
153 blockSize = 100;
154 printTestInfo(count, blockSize, __LINE__);
155
156 struct adios2::helper::BlockDivisionInfo subBlockInfo =
157 adios2::helper::DivideBlock(
158 count, blockSize,
159 adios2::helper::BlockDivisionMethod::Contiguous);
160 printBlockDivisionInfo(subBlockInfo);
161
162 /*blockID = 0;
163 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
164 assert_block(block, blockID, {0}, {100});*/
165
166 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
167 MinMaxs, Min, Max, 1);
168 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, {0, 99});
169 }
170
171 {
172 blockSize = 50;
173 printTestInfo(count, blockSize, __LINE__);
174
175 struct adios2::helper::BlockDivisionInfo subBlockInfo =
176 adios2::helper::DivideBlock(
177 count, blockSize,
178 adios2::helper::BlockDivisionMethod::Contiguous);
179 printBlockDivisionInfo(subBlockInfo);
180
181 /*blockID = 0;
182 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
183 assert_block(block, blockID, {0}, {50});
184
185 blockID = 1;
186 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
187 assert_block(block, blockID, {50}, {50});*/
188
189 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
190 MinMaxs, Min, Max, 1);
191 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
192 {0, 49, 50, 99});
193 }
194
195 {
196 blockSize = 17;
197 printTestInfo(count, blockSize, __LINE__);
198
199 struct adios2::helper::BlockDivisionInfo subBlockInfo =
200 adios2::helper::DivideBlock(
201 count, blockSize,
202 adios2::helper::BlockDivisionMethod::Contiguous);
203 printBlockDivisionInfo(subBlockInfo);
204
205 /*blockID = 0;
206 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
207 assert_block(block, blockID, {0}, {17});
208
209 blockID = 1;
210 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
211 assert_block(block, blockID, {17}, {17});
212
213 blockID = 2;
214 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
215 assert_block(block, blockID, {34}, {17});
216
217 blockID = 3;
218 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
219 assert_block(block, blockID, {51}, {17});
220
221 blockID = 4;
222 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
223 assert_block(block, blockID, {68}, {16});
224
225 blockID = 5;
226 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
227 assert_block(block, blockID, {84}, {16});*/
228
229 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
230 MinMaxs, Min, Max, 1);
231 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
232 {0, 16, 17, 33, 34, 50, 51, 67, 68, 83, 84, 99});
233 }
234
235 {
236 blockSize = 170;
237 printTestInfo(count, blockSize, __LINE__);
238
239 struct adios2::helper::BlockDivisionInfo subBlockInfo =
240 adios2::helper::DivideBlock(
241 count, blockSize,
242 adios2::helper::BlockDivisionMethod::Contiguous);
243 printBlockDivisionInfo(subBlockInfo);
244
245 /*blockID = 0;
246 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
247 assert_block(block, blockID, {0}, {100});*/
248
249 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
250 MinMaxs, Min, Max, 1);
251 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, {0, 99});
252 }
253
254 {
255 blockSize = 1;
256 printTestInfo(count, blockSize, __LINE__);
257
258 struct adios2::helper::BlockDivisionInfo subBlockInfo =
259 adios2::helper::DivideBlock(
260 count, blockSize,
261 adios2::helper::BlockDivisionMethod::Contiguous);
262 printBlockDivisionInfo(subBlockInfo);
263 ASSERT_EQ(subBlockInfo.NBlocks, 100);
264 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
265 ASSERT_EQ(subBlockInfo.Div.size(), 1);
266 ASSERT_EQ(subBlockInfo.Div[0], 100);
267 ASSERT_EQ(subBlockInfo.Rem.size(), 1);
268 ASSERT_EQ(subBlockInfo.Rem[0], 0);
269 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 1);
270 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
271
272 /*blockID = 0;
273 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
274 assert_block(block, blockID, {0}, {1});
275
276 blockID = 1;
277 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
278 assert_block(block, blockID, {1}, {1});
279
280 blockID = 77;
281 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
282 assert_block(block, blockID, {77}, {1});
283
284 blockID = 99;
285 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
286 assert_block(block, blockID, {99}, {1});*/
287
288 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
289 MinMaxs, Min, Max, 1);
290 std::vector<int> mm(200);
291 for (int j = 0; j < 100; j++)
292 {
293 mm[2 * j] = j;
294 mm[2 * j + 1] = j;
295 }
296 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, mm);
297 }
298 }
299
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_2D_10x10)300 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_2D_10x10)
301 {
302 std::vector<int> data(100);
303 for (int i = 0; i < data.size(); ++i)
304 {
305 data[i] = i;
306 }
307 size_t blockSize;
308 adios2::Dims count(2, 10);
309
310 adios2::Box<adios2::Dims> block;
311 // int blockID;
312 std::vector<int> MinMaxs;
313 int Min, Max;
314
315 {
316 blockSize = 100;
317 printTestInfo(count, blockSize, __LINE__);
318
319 struct adios2::helper::BlockDivisionInfo subBlockInfo =
320 adios2::helper::DivideBlock(
321 count, blockSize,
322 adios2::helper::BlockDivisionMethod::Contiguous);
323 printBlockDivisionInfo(subBlockInfo);
324
325 /*blockID = 0;
326 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
327 assert_block(block, blockID, {0, 0}, {10, 10});*/
328
329 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
330 MinMaxs, Min, Max, 1);
331 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, {0, 99});
332 }
333
334 {
335 blockSize = 50;
336 printTestInfo(count, blockSize, __LINE__);
337
338 struct adios2::helper::BlockDivisionInfo subBlockInfo =
339 adios2::helper::DivideBlock(
340 count, blockSize,
341 adios2::helper::BlockDivisionMethod::Contiguous);
342 printBlockDivisionInfo(subBlockInfo);
343
344 /*blockID = 0;
345 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
346 assert_block(block, blockID, {0, 0}, {5, 10});
347
348 blockID = 1;
349 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
350 assert_block(block, blockID, {5, 0}, {5, 10});*/
351
352 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
353 MinMaxs, Min, Max, 1);
354 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
355 {0, 49, 50, 99});
356 }
357
358 {
359 blockSize = 5;
360 printTestInfo(count, blockSize, __LINE__);
361
362 struct adios2::helper::BlockDivisionInfo subBlockInfo =
363 adios2::helper::DivideBlock(
364 count, blockSize,
365 adios2::helper::BlockDivisionMethod::Contiguous);
366 printBlockDivisionInfo(subBlockInfo);
367 ASSERT_EQ(subBlockInfo.NBlocks, 20);
368 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
369 ASSERT_EQ(subBlockInfo.Div.size(), 2);
370 ASSERT_EQ(subBlockInfo.Div[0], 10);
371 ASSERT_EQ(subBlockInfo.Div[1], 2);
372 ASSERT_EQ(subBlockInfo.Rem.size(), 2);
373 ASSERT_EQ(subBlockInfo.Rem[0], 0);
374 ASSERT_EQ(subBlockInfo.Rem[1], 0);
375 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
376 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 2);
377 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
378
379 /*blockID = 0;
380 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
381 assert_block(block, blockID, {0, 0}, {1, 5});
382
383 blockID = 1;
384 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
385 assert_block(block, blockID, {0, 5}, {1, 5});
386
387 blockID = 2;
388 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
389 assert_block(block, blockID, {1, 0}, {1, 5});
390
391 blockID = 3;
392 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
393 assert_block(block, blockID, {1, 5}, {1, 5});
394
395 blockID = 18;
396 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
397 assert_block(block, blockID, {9, 0}, {1, 5});
398
399 blockID = 19;
400 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
401 assert_block(block, blockID, {9, 5}, {1, 5});*/
402
403 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
404 MinMaxs, Min, Max, 1);
405 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
406 {0, 4, 5, 9, 10, 14, 15, 19, 20, 24, 25, 29, 30, 34,
407 35, 39, 40, 44, 45, 49, 50, 54, 55, 59, 60, 64, 65, 69,
408 70, 74, 75, 79, 80, 84, 85, 89, 90, 94, 95, 99});
409 }
410
411 {
412 blockSize = 17;
413 printTestInfo(count, blockSize, __LINE__);
414
415 struct adios2::helper::BlockDivisionInfo subBlockInfo =
416 adios2::helper::DivideBlock(
417 count, blockSize,
418 adios2::helper::BlockDivisionMethod::Contiguous);
419 printBlockDivisionInfo(subBlockInfo);
420 ASSERT_EQ(subBlockInfo.NBlocks, 6);
421 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
422 ASSERT_EQ(subBlockInfo.Div.size(), 2);
423 ASSERT_EQ(subBlockInfo.Div[0], 6);
424 ASSERT_EQ(subBlockInfo.Div[1], 1);
425 ASSERT_EQ(subBlockInfo.Rem.size(), 2);
426 ASSERT_EQ(subBlockInfo.Rem[0], 4);
427 ASSERT_EQ(subBlockInfo.Rem[1], 0);
428 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
429 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
430 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
431
432 /*blockID = 0;
433 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
434 assert_block(block, blockID, {0, 0}, {2, 10});
435
436 blockID = 1;
437 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
438 assert_block(block, blockID, {2, 0}, {2, 10});
439
440 blockID = 2;
441 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
442 assert_block(block, blockID, {4, 0}, {2, 10});
443
444 blockID = 3;
445 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
446 assert_block(block, blockID, {6, 0}, {2, 10});
447
448 blockID = 4;
449 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
450 assert_block(block, blockID, {8, 0}, {1, 10});
451
452 blockID = 5;
453 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
454 assert_block(block, blockID, {9, 0}, {1, 10});*/
455
456 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
457 MinMaxs, Min, Max, 1);
458 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
459 {0, 19, 20, 39, 40, 59, 60, 79, 80, 89, 90, 99});
460 }
461
462 {
463 blockSize = 170;
464 printTestInfo(count, blockSize, __LINE__);
465
466 struct adios2::helper::BlockDivisionInfo subBlockInfo =
467 adios2::helper::DivideBlock(
468 count, blockSize,
469 adios2::helper::BlockDivisionMethod::Contiguous);
470 printBlockDivisionInfo(subBlockInfo);
471 ASSERT_EQ(subBlockInfo.NBlocks, 1);
472 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
473 ASSERT_EQ(subBlockInfo.Div.size(), 2);
474 ASSERT_EQ(subBlockInfo.Div[0], 1);
475 ASSERT_EQ(subBlockInfo.Div[1], 1);
476 ASSERT_EQ(subBlockInfo.Rem.size(), 2);
477 ASSERT_EQ(subBlockInfo.Rem[0], 0);
478 ASSERT_EQ(subBlockInfo.Rem[1], 0);
479 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
480 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
481 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
482
483 /*blockID = 0;
484 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
485 assert_block(block, blockID, {0, 0}, {10, 10});*/
486
487 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
488 MinMaxs, Min, Max, 1);
489 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, {0, 99});
490 }
491
492 {
493 blockSize = 1;
494 printTestInfo(count, blockSize, __LINE__);
495
496 struct adios2::helper::BlockDivisionInfo subBlockInfo =
497 adios2::helper::DivideBlock(
498 count, blockSize,
499 adios2::helper::BlockDivisionMethod::Contiguous);
500 printBlockDivisionInfo(subBlockInfo);
501 ASSERT_EQ(subBlockInfo.NBlocks, 100);
502 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
503 ASSERT_EQ(subBlockInfo.Div.size(), 2);
504 ASSERT_EQ(subBlockInfo.Div[0], 10);
505 ASSERT_EQ(subBlockInfo.Div[1], 10);
506 ASSERT_EQ(subBlockInfo.Rem.size(), 2);
507 ASSERT_EQ(subBlockInfo.Rem[0], 0);
508 ASSERT_EQ(subBlockInfo.Rem[1], 0);
509 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
510 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 10);
511 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
512
513 /*blockID = 0;
514 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
515 assert_block(block, blockID, {0, 0}, {1, 1});
516
517 blockID = 1;
518 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
519 assert_block(block, blockID, {0, 1}, {1, 1});
520
521 blockID = 9;
522 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
523 assert_block(block, blockID, {0, 9}, {1, 1});
524
525 blockID = 10;
526 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
527 assert_block(block, blockID, {1, 0}, {1, 1});
528
529 blockID = 77;
530 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
531 assert_block(block, blockID, {7, 7}, {1, 1});
532
533 blockID = 99;
534 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
535 assert_block(block, blockID, {9, 9}, {1, 1});*/
536
537 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
538 MinMaxs, Min, Max, 1);
539 std::vector<int> mm(200);
540 for (int j = 0; j < 100; j++)
541 {
542 mm[2 * j] = j;
543 mm[2 * j + 1] = j;
544 }
545 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, mm);
546 }
547
548 {
549 blockSize = 3;
550 printTestInfo(count, blockSize, __LINE__);
551
552 struct adios2::helper::BlockDivisionInfo subBlockInfo =
553 adios2::helper::DivideBlock(
554 count, blockSize,
555 adios2::helper::BlockDivisionMethod::Contiguous);
556 printBlockDivisionInfo(subBlockInfo);
557 ASSERT_EQ(subBlockInfo.NBlocks, 30);
558 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
559 ASSERT_EQ(subBlockInfo.Div.size(), 2);
560 ASSERT_EQ(subBlockInfo.Div[0], 10);
561 ASSERT_EQ(subBlockInfo.Div[1], 3);
562 ASSERT_EQ(subBlockInfo.Rem.size(), 2);
563 ASSERT_EQ(subBlockInfo.Rem[0], 0);
564 ASSERT_EQ(subBlockInfo.Rem[1], 1);
565 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
566 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 3);
567
568 /*blockID = 0;
569 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
570 assert_block(block, blockID, {0, 0}, {1, 4});
571
572 blockID = 1;
573 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
574 assert_block(block, blockID, {0, 4}, {1, 3});
575
576 blockID = 2;
577 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
578 assert_block(block, blockID, {0, 7}, {1, 3});
579
580 blockID = 3;
581 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
582 assert_block(block, blockID, {1, 0}, {1, 4});
583
584 blockID = 4;
585 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
586 assert_block(block, blockID, {1, 4}, {1, 3});
587
588 blockID = 5;
589 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
590 assert_block(block, blockID, {1, 7}, {1, 3});
591
592 blockID = 27;
593 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
594 assert_block(block, blockID, {9, 0}, {1, 4});
595
596 blockID = 28;
597 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
598 assert_block(block, blockID, {9, 4}, {1, 3});
599
600 blockID = 29;
601 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
602 assert_block(block, blockID, {9, 7}, {1, 3}); */
603
604 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
605 MinMaxs, Min, Max, 1);
606 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
607 {0, 3, 4, 6, 7, 9, 10, 13, 14, 16, 17, 19,
608 20, 23, 24, 26, 27, 29, 30, 33, 34, 36, 37, 39,
609 40, 43, 44, 46, 47, 49, 50, 53, 54, 56, 57, 59,
610 60, 63, 64, 66, 67, 69, 70, 73, 74, 76, 77, 79,
611 80, 83, 84, 86, 87, 89, 90, 93, 94, 96, 97, 99});
612 }
613 }
614
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_3D_10x10x10)615 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_3D_10x10x10)
616 {
617 std::vector<int> data(1000);
618 for (int i = 0; i < data.size(); ++i)
619 {
620 data[i] = i;
621 }
622 size_t blockSize;
623 adios2::Dims count(3, 10);
624
625 adios2::Box<adios2::Dims> block;
626 // int blockID;
627 std::vector<int> MinMaxs;
628 int Min, Max;
629
630 {
631 blockSize = 100;
632 printTestInfo(count, blockSize, __LINE__);
633
634 struct adios2::helper::BlockDivisionInfo subBlockInfo =
635 adios2::helper::DivideBlock(
636 count, blockSize,
637 adios2::helper::BlockDivisionMethod::Contiguous);
638 printBlockDivisionInfo(subBlockInfo);
639 ASSERT_EQ(subBlockInfo.NBlocks, 10);
640 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
641 ASSERT_EQ(subBlockInfo.Div.size(), 3);
642 ASSERT_EQ(subBlockInfo.Div[0], 10);
643 ASSERT_EQ(subBlockInfo.Div[1], 1);
644 ASSERT_EQ(subBlockInfo.Div[2], 1);
645 ASSERT_EQ(subBlockInfo.Rem.size(), 3);
646 ASSERT_EQ(subBlockInfo.Rem[0], 0);
647 ASSERT_EQ(subBlockInfo.Rem[1], 0);
648 ASSERT_EQ(subBlockInfo.Rem[2], 0);
649 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
650 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
651 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
652 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
653
654 /*blockID = 0;
655 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
656 assert_block(block, blockID, {0, 0, 0}, {1, 10, 10});
657
658 blockID = 1;
659 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
660 assert_block(block, blockID, {1, 0, 0}, {1, 10, 10});
661
662 blockID = 9;
663 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
664 assert_block(block, blockID, {9, 0, 0}, {1, 10, 10});*/
665
666 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
667 MinMaxs, Min, Max, 1);
668 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999,
669 {0, 99, 100, 199, 200, 299, 300, 399, 400, 499,
670 500, 599, 600, 699, 700, 799, 800, 899, 900, 999});
671 }
672
673 {
674 blockSize = 500;
675 printTestInfo(count, blockSize, __LINE__);
676
677 struct adios2::helper::BlockDivisionInfo subBlockInfo =
678 adios2::helper::DivideBlock(
679 count, blockSize,
680 adios2::helper::BlockDivisionMethod::Contiguous);
681 printBlockDivisionInfo(subBlockInfo);
682 ASSERT_EQ(subBlockInfo.NBlocks, 2);
683 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
684 ASSERT_EQ(subBlockInfo.Div.size(), 3);
685 ASSERT_EQ(subBlockInfo.Div[0], 2);
686 ASSERT_EQ(subBlockInfo.Div[1], 1);
687 ASSERT_EQ(subBlockInfo.Div[2], 1);
688 ASSERT_EQ(subBlockInfo.Rem.size(), 3);
689 ASSERT_EQ(subBlockInfo.Rem[0], 0);
690 ASSERT_EQ(subBlockInfo.Rem[1], 0);
691 ASSERT_EQ(subBlockInfo.Rem[2], 0);
692 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
693 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
694 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
695 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
696
697 /*blockID = 0;
698 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
699 assert_block(block, blockID, {0, 0, 0}, {5, 10, 10});
700
701 blockID = 1;
702 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
703 assert_block(block, blockID, {5, 0, 0}, {5, 10, 10});*/
704 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
705 MinMaxs, Min, Max, 1);
706 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999,
707 {0, 499, 500, 999});
708 }
709
710 {
711 blockSize = 50;
712 printTestInfo(count, blockSize, __LINE__);
713
714 struct adios2::helper::BlockDivisionInfo subBlockInfo =
715 adios2::helper::DivideBlock(
716 count, blockSize,
717 adios2::helper::BlockDivisionMethod::Contiguous);
718 printBlockDivisionInfo(subBlockInfo);
719 ASSERT_EQ(subBlockInfo.NBlocks, 20);
720 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
721 ASSERT_EQ(subBlockInfo.Div.size(), 3);
722 ASSERT_EQ(subBlockInfo.Div[0], 10);
723 ASSERT_EQ(subBlockInfo.Div[1], 2);
724 ASSERT_EQ(subBlockInfo.Div[2], 1);
725 ASSERT_EQ(subBlockInfo.Rem.size(), 3);
726 ASSERT_EQ(subBlockInfo.Rem[0], 0);
727 ASSERT_EQ(subBlockInfo.Rem[1], 0);
728 ASSERT_EQ(subBlockInfo.Rem[2], 0);
729 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
730 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 2);
731 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
732 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
733
734 /*blockID = 0;
735 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
736 assert_block(block, blockID, {0, 0, 0}, {1, 5, 10});
737
738 blockID = 1;
739 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
740 assert_block(block, blockID, {0, 5, 0}, {1, 5, 10});
741
742 blockID = 2;
743 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
744 assert_block(block, blockID, {1, 0, 0}, {1, 5, 10});
745
746 blockID = 3;
747 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
748 assert_block(block, blockID, {1, 5, 0}, {1, 5, 10});
749
750 blockID = 18;
751 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
752 assert_block(block, blockID, {9, 0, 0}, {1, 5, 10});
753
754 blockID = 19;
755 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
756 assert_block(block, blockID, {9, 5, 0}, {1, 5, 10});*/
757
758 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
759 MinMaxs, Min, Max, 1);
760 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999,
761 {0, 49, 50, 99, 100, 149, 150, 199, 200, 249,
762 250, 299, 300, 349, 350, 399, 400, 449, 450, 499,
763 500, 549, 550, 599, 600, 649, 650, 699, 700, 749,
764 750, 799, 800, 849, 850, 899, 900, 949, 950, 999});
765 }
766
767 {
768 blockSize = 17;
769 printTestInfo(count, blockSize, __LINE__);
770
771 struct adios2::helper::BlockDivisionInfo subBlockInfo =
772 adios2::helper::DivideBlock(
773 count, blockSize,
774 adios2::helper::BlockDivisionMethod::Contiguous);
775 printBlockDivisionInfo(subBlockInfo);
776 ASSERT_EQ(subBlockInfo.NBlocks, 50);
777 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
778 ASSERT_EQ(subBlockInfo.Div.size(), 3);
779 ASSERT_EQ(subBlockInfo.Div[0], 10);
780 ASSERT_EQ(subBlockInfo.Div[1], 5);
781 ASSERT_EQ(subBlockInfo.Div[2], 1);
782 ASSERT_EQ(subBlockInfo.Rem.size(), 3);
783 ASSERT_EQ(subBlockInfo.Rem[0], 0);
784 ASSERT_EQ(subBlockInfo.Rem[1], 0);
785 ASSERT_EQ(subBlockInfo.Rem[2], 0);
786 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
787 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 5);
788 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
789 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
790
791 /*blockID = 0;
792 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
793 assert_block(block, blockID, {0, 0, 0}, {1, 2, 10});
794
795 blockID = 1;
796 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
797 assert_block(block, blockID, {0, 2, 0}, {1, 2, 10});
798
799 blockID = 2;
800 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
801 assert_block(block, blockID, {0, 4, 0}, {1, 2, 10});
802
803 blockID = 4;
804 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
805 assert_block(block, blockID, {0, 8, 0}, {1, 2, 10});
806
807 blockID = 5;
808 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
809 assert_block(block, blockID, {1, 0, 0}, {1, 2, 10});
810
811 blockID = 48;
812 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
813 assert_block(block, blockID, {9, 6, 0}, {1, 2, 10});
814
815 blockID = 49;
816 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
817 assert_block(block, blockID, {9, 8, 0}, {1, 2, 10});*/
818
819 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
820 MinMaxs, Min, Max, 1);
821 std::vector<int> mm(100);
822 for (int j = 0; j < 50; j++)
823 {
824 mm[2 * j] = 20 * j;
825 mm[2 * j + 1] = 20 * j + 19;
826 }
827 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999, mm);
828 }
829
830 {
831 blockSize = 170;
832 printTestInfo(count, blockSize, __LINE__);
833
834 struct adios2::helper::BlockDivisionInfo subBlockInfo =
835 adios2::helper::DivideBlock(
836 count, blockSize,
837 adios2::helper::BlockDivisionMethod::Contiguous);
838 printBlockDivisionInfo(subBlockInfo);
839 ASSERT_EQ(subBlockInfo.NBlocks, 6);
840 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
841 ASSERT_EQ(subBlockInfo.Div.size(), 3);
842 ASSERT_EQ(subBlockInfo.Div[0], 6);
843 ASSERT_EQ(subBlockInfo.Div[1], 1);
844 ASSERT_EQ(subBlockInfo.Div[2], 1);
845 ASSERT_EQ(subBlockInfo.Rem.size(), 3);
846 ASSERT_EQ(subBlockInfo.Rem[0], 4);
847 ASSERT_EQ(subBlockInfo.Rem[1], 0);
848 ASSERT_EQ(subBlockInfo.Rem[2], 0);
849 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
850 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
851 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
852 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
853
854 /*blockID = 0;
855 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
856 assert_block(block, blockID, {0, 0, 0}, {2, 10, 10});
857
858 blockID = 1;
859 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
860 assert_block(block, blockID, {2, 0, 0}, {2, 10, 10});
861
862 blockID = 2;
863 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
864 assert_block(block, blockID, {4, 0, 0}, {2, 10, 10});
865
866 blockID = 3;
867 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
868 assert_block(block, blockID, {6, 0, 0}, {2, 10, 10});
869
870 blockID = 4;
871 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
872 assert_block(block, blockID, {8, 0, 0}, {1, 10, 10});
873
874 blockID = 5;
875 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
876 assert_block(block, blockID, {9, 0, 0}, {1, 10, 10}); */
877
878 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
879 MinMaxs, Min, Max, 1);
880 assert_minmax(
881 subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999,
882 {0, 199, 200, 399, 400, 599, 600, 799, 800, 899, 900, 999});
883 }
884
885 {
886 blockSize = 1;
887 printTestInfo(count, blockSize, __LINE__);
888
889 struct adios2::helper::BlockDivisionInfo subBlockInfo =
890 adios2::helper::DivideBlock(
891 count, blockSize,
892 adios2::helper::BlockDivisionMethod::Contiguous);
893 printBlockDivisionInfo(subBlockInfo);
894 ASSERT_EQ(subBlockInfo.NBlocks, 1000);
895 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
896 ASSERT_EQ(subBlockInfo.Div.size(), 3);
897 ASSERT_EQ(subBlockInfo.Div[0], 10);
898 ASSERT_EQ(subBlockInfo.Div[1], 10);
899 ASSERT_EQ(subBlockInfo.Div[2], 10);
900 ASSERT_EQ(subBlockInfo.Rem.size(), 3);
901 ASSERT_EQ(subBlockInfo.Rem[0], 0);
902 ASSERT_EQ(subBlockInfo.Rem[1], 0);
903 ASSERT_EQ(subBlockInfo.Rem[2], 0);
904 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
905 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 100);
906 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 10);
907 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
908
909 /*blockID = 0;
910 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
911 assert_block(block, blockID, {0, 0, 0}, {1, 1, 1});
912
913 blockID = 1;
914 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
915 assert_block(block, blockID, {0, 0, 1}, {1, 1, 1});
916
917 blockID = 10;
918 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
919 assert_block(block, blockID, {0, 1, 0}, {1, 1, 1});
920
921 blockID = 17;
922 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
923 assert_block(block, blockID, {0, 1, 7}, {1, 1, 1});
924
925 blockID = 536;
926 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
927 assert_block(block, blockID, {5, 3, 6}, {1, 1, 1});
928
929 blockID = 999;
930 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
931 assert_block(block, blockID, {9, 9, 9}, {1, 1, 1});*/
932
933 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
934 MinMaxs, Min, Max, 1);
935 std::vector<int> mm(2000);
936 for (int j = 0; j < 1000; j++)
937 {
938 mm[2 * j] = j;
939 mm[2 * j + 1] = j;
940 }
941 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999, mm);
942 }
943
944 {
945 blockSize = 3;
946 printTestInfo(count, blockSize, __LINE__);
947
948 struct adios2::helper::BlockDivisionInfo subBlockInfo =
949 adios2::helper::DivideBlock(
950 count, blockSize,
951 adios2::helper::BlockDivisionMethod::Contiguous);
952 printBlockDivisionInfo(subBlockInfo);
953 ASSERT_EQ(subBlockInfo.NBlocks, 300);
954 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
955 ASSERT_EQ(subBlockInfo.Div.size(), 3);
956 ASSERT_EQ(subBlockInfo.Div[0], 10);
957 ASSERT_EQ(subBlockInfo.Div[1], 10);
958 ASSERT_EQ(subBlockInfo.Div[2], 3);
959 ASSERT_EQ(subBlockInfo.Rem.size(), 3);
960 ASSERT_EQ(subBlockInfo.Rem[0], 0);
961 ASSERT_EQ(subBlockInfo.Rem[1], 0);
962 ASSERT_EQ(subBlockInfo.Rem[2], 1);
963 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
964 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 30);
965 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 3);
966 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
967
968 /*blockID = 0;
969 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
970 assert_block(block, blockID, {0, 0, 0}, {1, 1, 4});
971
972 blockID = 1;
973 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
974 assert_block(block, blockID, {0, 0, 4}, {1, 1, 3});
975
976 blockID = 2;
977 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
978 assert_block(block, blockID, {0, 0, 7}, {1, 1, 3});
979
980 blockID = 3;
981 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
982 assert_block(block, blockID, {0, 1, 0}, {1, 1, 4});
983
984 blockID = 29;
985 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
986 assert_block(block, blockID, {0, 9, 7}, {1, 1, 3});
987
988 blockID = 30;
989 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
990 assert_block(block, blockID, {1, 0, 0}, {1, 1, 4});
991
992 blockID = 60;
993 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
994 assert_block(block, blockID, {2, 0, 0}, {1, 1, 4});
995
996 blockID = 180;
997 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
998 assert_block(block, blockID, {6, 0, 0}, {1, 1, 4});
999
1000 blockID = 217;
1001 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1002 assert_block(block, blockID, {7, 2, 4}, {1, 1, 3});
1003
1004 blockID = 299;
1005 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1006 assert_block(block, blockID, {9, 9, 7}, {1, 1, 3});*/
1007
1008 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
1009 MinMaxs, Min, Max, 1);
1010 std::vector<int> mm(600);
1011 for (int i = 0; i < 10; i++)
1012 {
1013 for (int j = 0; j < 10; j++)
1014 {
1015 int idx = i * 10 + j;
1016 int minstart = 100 * i + 10 * j;
1017 int k = 6 * idx;
1018 mm[k++] = minstart;
1019 mm[k++] = minstart + 3;
1020 mm[k++] = minstart + 4;
1021 mm[k++] = minstart + 6;
1022 mm[k++] = minstart + 7;
1023 mm[k++] = minstart + 9;
1024 }
1025 }
1026 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999, mm);
1027 }
1028 }
1029
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_3D_24x24x48)1030 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_3D_24x24x48)
1031 {
1032 std::vector<int> data(27648);
1033 for (int i = 0; i < data.size(); ++i)
1034 {
1035 data[i] = i;
1036 }
1037 size_t blockSize;
1038 adios2::Dims count({24, 24, 48});
1039
1040 adios2::Box<adios2::Dims> block;
1041 // int blockID;
1042
1043 std::vector<int> MinMaxs;
1044 int Min, Max;
1045
1046 {
1047 blockSize = 5000;
1048 printTestInfo(count, blockSize, __LINE__);
1049
1050 struct adios2::helper::BlockDivisionInfo subBlockInfo =
1051 adios2::helper::DivideBlock(
1052 count, blockSize,
1053 adios2::helper::BlockDivisionMethod::Contiguous);
1054 printBlockDivisionInfo(subBlockInfo);
1055 ASSERT_EQ(subBlockInfo.NBlocks, 6);
1056 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
1057 ASSERT_EQ(subBlockInfo.Div.size(), 3);
1058 ASSERT_EQ(subBlockInfo.Div[0], 6);
1059 ASSERT_EQ(subBlockInfo.Div[1], 1);
1060 ASSERT_EQ(subBlockInfo.Div[2], 1);
1061 ASSERT_EQ(subBlockInfo.Rem.size(), 3);
1062 ASSERT_EQ(subBlockInfo.Rem[0], 0);
1063 ASSERT_EQ(subBlockInfo.Rem[1], 0);
1064 ASSERT_EQ(subBlockInfo.Rem[2], 0);
1065 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
1066 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
1067 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
1068 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
1069
1070 /*blockID = 0;
1071 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1072 assert_block(block, blockID, {0, 0, 0}, {4, 24, 48});
1073
1074 blockID = 1;
1075 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1076 assert_block(block, blockID, {4, 0, 0}, {4, 24, 48});
1077
1078 blockID = 5;
1079 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1080 assert_block(block, blockID, {20, 0, 0}, {4, 24, 48});*/
1081
1082 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
1083 MinMaxs, Min, Max, 1);
1084 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 27647,
1085 {0, 4607, 4608, 9215, 9216, 13823, 13824, 18431, 18432,
1086 23039, 23040, 27647});
1087 }
1088 }
1089
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_4D_3x2x5x4)1090 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_4D_3x2x5x4)
1091 {
1092 std::vector<int> data(120);
1093 for (int i = 0; i < data.size(); ++i)
1094 {
1095 data[i] = i;
1096 }
1097 size_t blockSize;
1098 adios2::Dims count({3, 2, 5, 4});
1099
1100 adios2::Box<adios2::Dims> block;
1101 // int blockID;
1102
1103 std::vector<int> MinMaxs;
1104 int Min, Max;
1105
1106 {
1107 blockSize = 6;
1108 printTestInfo(count, blockSize, __LINE__);
1109
1110 struct adios2::helper::BlockDivisionInfo subBlockInfo =
1111 adios2::helper::DivideBlock(
1112 count, blockSize,
1113 adios2::helper::BlockDivisionMethod::Contiguous);
1114 printBlockDivisionInfo(subBlockInfo);
1115 ASSERT_EQ(subBlockInfo.NBlocks, 18);
1116 ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
1117 ASSERT_EQ(subBlockInfo.Div.size(), 4);
1118 ASSERT_EQ(subBlockInfo.Div[0], 3);
1119 ASSERT_EQ(subBlockInfo.Div[1], 2);
1120 ASSERT_EQ(subBlockInfo.Div[2], 3);
1121 ASSERT_EQ(subBlockInfo.Div[3], 1);
1122 ASSERT_EQ(subBlockInfo.Rem.size(), 4);
1123 ASSERT_EQ(subBlockInfo.Rem[0], 0);
1124 ASSERT_EQ(subBlockInfo.Rem[1], 0);
1125 ASSERT_EQ(subBlockInfo.Rem[2], 2);
1126 ASSERT_EQ(subBlockInfo.Rem[3], 0);
1127 ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 4);
1128 ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 6);
1129 ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 3);
1130 ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
1131 ASSERT_EQ(subBlockInfo.ReverseDivProduct[3], 1);
1132
1133 /*blockID = 0;
1134 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1135 assert_block(block, blockID, {0, 0, 0, 0}, {1, 1, 2, 4});
1136
1137 blockID = 1;
1138 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1139 assert_block(block, blockID, {0, 0, 2, 0}, {1, 1, 2, 4});
1140
1141 blockID = 2;
1142 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1143 assert_block(block, blockID, {0, 0, 4, 0}, {1, 1, 1, 4});
1144
1145 blockID = 3;
1146 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1147 assert_block(block, blockID, {0, 1, 0, 0}, {1, 1, 2, 4});
1148
1149 blockID = 4;
1150 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1151 assert_block(block, blockID, {0, 1, 2, 0}, {1, 1, 2, 4});
1152
1153 blockID = 5;
1154 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1155 assert_block(block, blockID, {0, 1, 4, 0}, {1, 1, 1, 4});
1156
1157 blockID = 6;
1158 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1159 assert_block(block, blockID, {1, 0, 0, 0}, {1, 1, 2, 4});
1160
1161 blockID = 17;
1162 block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1163 assert_block(block, blockID, {2, 1, 4, 0}, {1, 1, 1, 4});*/
1164
1165 adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
1166 MinMaxs, Min, Max, 1);
1167 assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 119,
1168 {0, 7, 8, 15, 16, 19, 20, 27, 28, 35, 36, 39,
1169 40, 47, 48, 55, 56, 59, 60, 67, 68, 75, 76, 79,
1170 80, 87, 88, 95, 96, 99, 100, 107, 108, 115, 116, 119});
1171 }
1172 }
1173
main(int argc,char ** argv)1174 int main(int argc, char **argv)
1175 {
1176
1177 int result;
1178 ::testing::InitGoogleTest(&argc, argv);
1179 result = RUN_ALL_TESTS();
1180
1181 return result;
1182 }
1183