Helios++
Helios software for LiDAR simulations
HPCTest.h
1 #pragma once
2 
3 #include <BaseTest.h>
4 #include <hpc/SM_ParallelMergeSort.h>
5 
6 #include <algorithm>
7 
8 using namespace helios::hpc;
9 
10 namespace HeliosTests{
16 class HPCTest : public BaseTest{
17 public:
18  // *** ATTRIBUTES *** //
19  // ******************** //
20 
21  // *** CONSTRUCTOR *** //
22  // ********************* //
26  HPCTest() : BaseTest("HPC test"){}
27 
28  // *** R U N *** //
29  // *************** //
30  bool run() override;
31 
32  // *** SHARED-MEMORY TESTS *** //
33  // ***************************** //
38  bool SM_testParallelMergeSort();
39 };
40 
41 // *** COMPARATORS *** //
42 // ********************* //
44  bool operator() (int i, int j) {return (i<j);}
45 };
47  bool operator() (float i, float j) {return (i<j);}
48 };
50  bool operator() (double i, double j) {return (i<j);}
51 };
52 
53 // *** R U N *** //
54 // *************** //
55 bool HPCTest::run(){
56  // Run shared-memory tests
57  if(!SM_testParallelMergeSort()) return false;
58 
59  // All test passed
60  return true;
61 }
62 
63 // *** SHARED-MEMORY TESTS *** //
64 // ***************************** //
65 bool HPCTest::SM_testParallelMergeSort(){
66  // Build data to be sorted
67  std::vector<int> X1({1, 7, 6, 5, 2, 3, 9, 11, 25, -7, -8, 3, -3, 6});
68  std::vector<float> X2({1.0, -1.0, 2.0});
69  std::vector<double> X3({-1.0, 1.0, -2.0, 2.0, 3.5, 2.5, 7.1, -3.6, 2.88});
70  std::vector<int> X4({
71  22, 12, 27, 14, 31, 21, 12, 21, 3, 0, 14, 5, 3, 28, 8, 9, 23,
72  30, 22, 8, 23, 16, 7, 16, 14, 7, 6, 2, 8, 15, 2, 3, 0, 6,
73  6, 11, 10, 0, 7, 7, 11, 28, 28, 21, 23, 16, 18, 17, 8, 23, 1,
74  29, 2, 17, 16, 17, 11, 13, 13, 3, 4, 20, 20, 15, 18, 0, 0, 27,
75  14, 11, 18, 10, 14, 6, 6, 25, 11, 18, 3, 5, 10, 2, 30, 24, 9,
76  13, 24, 18, 9, 31, 1, 19, 3, 2, 12, 30, 15, 21, 15, 23, 20, 26,
77  25, 17, 16, 13, 25, 18, 1, 15, 7, 8, 22, 15, 0, 8, 19, 17, 8,
78  15, 16, 19, 16, 4, 5, 8, 21, 16, 1, 16, 21, 21, 27, 18, 10, 5,
79  14, 6, 5, 27, 31, 28, 5, 5, 11, 1, 8, 17, 2, 18, 8, 22, 28,
80  3, 12, 7, 9, 17, 13, 0, 10, 26, 28, 13, 14, 21, 16, 7, 11, 14,
81  28, 11, 28, 22, 8, 9, 29, 8, 28, 10, 12, 31, 27, 24, 20, 2, 23,
82  8, 13, 0, 23, 0, 19, 11, 4, 9, 8, 24, 8, 28
83  });
84  std::vector<int> X5({
85  22, 12, 27, 14, 31, 21, 12, 21, 3, 0, 14, 5, 3, 28, 8, 9, 23,
86  30, 22, 8, 23, 16, 7, 16, 14, 7, 6, 2, 8, 15, 2, 3, 0, 6,
87  6, 11, 10, 0, 7, 7, 11, 28, 28, 21, 23, 16, 18, 17, 8, 23, 1,
88  29, 2, 17, 16, 17, 11, 13, 13, 3, 4, 20, 20, 15, 18, 0, 0, 27,
89  14, 11, 18, 10, 14, 6, 6, 25, 11, 18, 3, 5, 10, 2, 30, 24, 9,
90  13, 24, 18, 9, 31, 1, 19, 3, 2, 12, 30, 15, 21, 15, 23, 20, 26,
91  25, 17, 16, 13, 25, 18, 1, 15, 7, 8, 22, 15, 0, 8, 19, 17, 8,
92  15, 16, 19, 16, 4, 5, 8, 21, 16, 1, 16, 21, 21, 27, 18, 10, 5,
93  14, 6, 5, 27, 31, 28, 5, 5, 11, 1, 8, 17, 2, 18, 8, 22, 28,
94  3, 12, 7, 9, 17, 13, 0, 10, 26, 28, 13, 14, 21, 16, 7, 11, 14,
95  28, 11, 28, 22, 8, 9, 29, 8, 28, 10, 12, 31, 27, 24, 20, 2, 23,
96  8, 13, 0, 23, 0, 19, 11, 4, 9, 8, 24, 8
97  });
98 
99  // Build expected output
100  std::vector<int> Y1({-8, -7, -3, 1, 2, 3, 3, 5, 6, 6, 7, 9, 11, 25});
101  std::vector<float> Y2({-1.0, 1.0, 2.0});
102  std::vector<double> Y3({-3.6, -2.0, -1.0, 1.0, 2.0, 2.5, 2.88, 3.5, 7.1});
103  std::vector<int> Y4({
104  0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2,
105  2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5,
106  5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
107  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9,
108  9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11,
109  11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14,
110  14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16,
111  16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18,
112  18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21,
113  21, 21, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24,
114  24, 25, 25, 25, 26, 26, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28,
115  28, 28, 28, 28, 29, 29, 30, 30, 30, 31, 31, 31, 31
116  });
117  std::vector<int> Y5({
118  0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2,
119  2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5,
120  5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
121  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9,
122  9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11,
123  11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14,
124  14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16,
125  16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18,
126  18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21,
127  21, 21, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24,
128  24, 25, 25, 25, 26, 26, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28,
129  28, 28, 28, 28, 29, 29, 30, 30, 30, 31, 31, 31, 31
130  });
131 
132  // Build sorters
134  PMS2T1(2, 4); // 2 Threads, for ints
136  PMS2T2(2, 4); // 2 Threads, for floats
138  std::vector<double>::iterator,
140  > PMS2T3(2, 4); // 2 Threads, for doubles
142  PMS3T1(3, 6); // 3 Threads, for ints
144  PMS3T2(3, 6); // 3 Threads, for floats
146  std::vector<double>::iterator,
148  > PMS3T3(3, 6); // 3 Threads, for doubles
150  PMS11T1(11, 22); // 11 Threads, for ints
152  PMS11T2(11, 22); // 11 Threads, for floats
154  std::vector<double>::iterator,
156  > PMS11T3(11, 22); // 11 Threads, for doubles
158  PMS16T1(16, 32); // 16 Threads, for ints
160  PMS16T2(16, 32); // 16 Threads, for floats
162  std::vector<double>::iterator,
164  > PMS16T3(16, 32); // 16 Threads, for doubles
165 
166  // Test 2 threads sorter
167  std::vector<int> Z1(X1);
168  PMS2T1.sort(Z1.begin(), Z1.end(), HPCTest_IntComparator());
169  if(Y1.size() != Z1.size()) return false;
170  if(!std::equal(Y1.begin(), Y1.end(), Z1.begin())) return false;
171  std::vector<float> Z2(X2);
172  PMS2T2.sort(Z2.begin(), Z2.end(), HPCTest_FloatComparator());
173  if(Y2.size() != Z2.size()) return false;
174  if(!std::equal(Y2.begin(), Y2.end(), Z2.begin())) return false;
175  std::vector<double> Z3(X3);
176  PMS2T3.sort(Z3.begin(), Z3.end(), HPCTest_DoubleComparator());
177  if(Y3.size() != Z3.size()) return false;
178  if(!std::equal(Y3.begin(), Y3.end(), Z3.begin())) return false;
179  std::vector<int> Z4(X4);
180  PMS2T1.sort(Z4.begin(), Z4.end(), HPCTest_IntComparator());
181  if(Y4.size() != Z4.size()) return false;
182  if(!std::equal(Y4.begin(), Y4.end(), Z4.begin())) return false;
183  std::vector<int> Z5(X5);
184  PMS2T1.sort(Z5.begin(), Z5.end(), HPCTest_IntComparator());
185  if(Y5.size() != Z5.size()) return false;
186  if(!std::equal(Y5.begin(), Y5.end(), Z5.begin())) return false;
187 
188  // Test 3 threads sorter
189  Z1 = std::vector<int>(X1);
190  PMS3T1.sort(Z1.begin(), Z1.end(), HPCTest_IntComparator());
191  if(Y1.size() != Z1.size()) return false;
192  if(!std::equal(Y1.begin(), Y1.end(), Z1.begin())) return false;
193  Z2 = std::vector<float>(X2);
194  PMS3T2.sort(Z2.begin(), Z2.end(), HPCTest_FloatComparator());
195  if(Y2.size() != Z2.size()) return false;
196  if(!std::equal(Y2.begin(), Y2.end(), Z2.begin())) return false;
197  Z3 = std::vector<double>(X3);
198  PMS3T3.sort(Z3.begin(), Z3.end(), HPCTest_DoubleComparator());
199  if(Y3.size() != Z3.size()) return false;
200  if(!std::equal(Y3.begin(), Y3.end(), Z3.begin())) return false;
201  Z4 = std::vector<int>(X4);
202  PMS3T1.sort(Z4.begin(), Z4.end(), HPCTest_IntComparator());
203  if(Y4.size() != Z4.size()) return false;
204  if(!std::equal(Y4.begin(), Y4.end(), Z4.begin())) return false;
205  Z5 = std::vector<int>(X5);
206  PMS3T1.sort(Z5.begin(), Z5.end(), HPCTest_IntComparator());
207  if(Y5.size() != Z5.size()) return false;
208  if(!std::equal(Y5.begin(), Y5.end(), Z5.begin())) return false;
209 
210  // Test 11 threads sorter
211  Z1 = std::vector<int>(X1);
212  PMS11T1.sort(Z1.begin(), Z1.end(), HPCTest_IntComparator());
213  if(Y1.size() != Z1.size()) return false;
214  if(!std::equal(Y1.begin(), Y1.end(), Z1.begin())) return false;
215  Z2 = std::vector<float>(X2);
216  PMS11T2.sort(Z2.begin(), Z2.end(), HPCTest_FloatComparator());
217  if(Y2.size() != Z2.size()) return false;
218  if(!std::equal(Y2.begin(), Y2.end(), Z2.begin())) return false;
219  Z3 = std::vector<double>(X3);
220  PMS11T3.sort(Z3.begin(), Z3.end(), HPCTest_DoubleComparator());
221  if(Y3.size() != Z3.size()) return false;
222  if(!std::equal(Y3.begin(), Y3.end(), Z3.begin())) return false;
223  Z4 = std::vector<int>(X4);
224  PMS11T1.sort(Z4.begin(), Z4.end(), HPCTest_IntComparator());
225  if(Y4.size() != Z4.size()) return false;
226  if(!std::equal(Y4.begin(), Y4.end(), Z4.begin())) return false;
227  Z5 = std::vector<int>(X5);
228  PMS11T1.sort(Z5.begin(), Z5.end(), HPCTest_IntComparator());
229  if(Y5.size() != Z5.size()) return false;
230  if(!std::equal(Y5.begin(), Y5.end(), Z5.begin())) return false;
231 
232  // Test 16 threads sorter
233  Z1 = std::vector<int>(X1);
234  PMS16T1.sort(Z1.begin(), Z1.end(), HPCTest_IntComparator());
235  if(Y1.size() != Z1.size()) return false;
236  if(!std::equal(Y1.begin(), Y1.end(), Z1.begin())) return false;
237  Z2 = std::vector<float>(X2);
238  PMS16T2.sort(Z2.begin(), Z2.end(), HPCTest_FloatComparator());
239  if(Y2.size() != Z2.size()) return false;
240  if(!std::equal(Y2.begin(), Y2.end(), Z2.begin())) return false;
241  Z3 = std::vector<double>(X3);
242  PMS16T3.sort(Z3.begin(), Z3.end(), HPCTest_DoubleComparator());
243  if(Y3.size() != Z3.size()) return false;
244  if(!std::equal(Y3.begin(), Y3.end(), Z3.begin())) return false;
245  Z4 = std::vector<int>(X4);
246  PMS16T1.sort(Z4.begin(), Z4.end(), HPCTest_IntComparator());
247  if(Y4.size() != Z4.size()) return false;
248  if(!std::equal(Y4.begin(), Y4.end(), Z4.begin())) return false;
249  Z5 = std::vector<int>(X5);
250  PMS16T1.sort(Z5.begin(), Z5.end(), HPCTest_IntComparator());
251  if(Y5.size() != Z5.size()) return false;
252  if(!std::equal(Y5.begin(), Y5.end(), Z5.begin())) return false;
253 
254  // All checks passed
255  return true;
256 }
257 
258 }
BaseTest class.
Definition: BaseTest.h:20
High performance computing components test.
Definition: HPCTest.h:16
HPCTest()
HPC test constructor.
Definition: HPCTest.h:26
Class providing a shared memory sorting algorithm based on merge sort.
Definition: SM_ParallelMergeSort.h:25
virtual void sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comparator)
Like SM_ParallelMergeSort::trySort function but it returns only after sorting has been finished....
Definition: SM_ParallelMergeSort.h:115
Definition: HPCTest.h:46
Definition: HPCTest.h:43