This source file includes following definitions.
- sqr
- BOOST_AUTO_TEST_SUITE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_SUITE_END
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_SUITE_END
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_SUITE_END
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
- BOOST_AUTO_TEST_CASE_TEMPLATE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 #include "stdafx.h"
22
23 #define BOOST_TEST_MODULE libjmmcg_tests
24 #include <boost/test/included/unit_test.hpp>
25
26 #include <boost/test/test_case_template.hpp>
27 #include <boost/mpl/list.hpp>
28
29 #include "core/thread_pool_sequential.hpp"
30 #include "core/thread_pool_master.hpp"
31 #include "core/thread_pool_workers.hpp"
32
33 using namespace jmmcg;
34 using namespace jmmcg::ppd;
35
36 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize=0, unsigned int GSSk=1>
37 struct crew_normal_fifo_t {
38 typedef api_lock_traits<platform_api, Mdl> lock_traits;
39 typedef safe_colln<
40 std::vector<long>,
41 typename lock::rw::locker<lock_traits>,
42 typename lock::rw::locker<lock_traits>::decaying_write_lock_type
43 > vtr_colln_t;
44
45 typedef pool_aspects<
46 Jn,
47 platform_api,
48 Mdl,
49 pool_traits::normal_fifo,
50 std::less,
51 GSSk
52 > thread_pool_traits;
53
54 typedef thread_pool<Db, Sz, thread_pool_traits> pool_type;
55
56 static const typename pool_type::pool_type::size_type pool_size=PoolSize;
57 };
58
59 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize, unsigned int GSSk>
60 const typename crew_normal_fifo_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_type::pool_type::size_type crew_normal_fifo_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_size;
61
62 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize=0, unsigned int GSSk=1>
63 struct crew_priority_queue_t {
64 typedef api_lock_traits<platform_api, Mdl> lock_traits;
65 typedef safe_colln<
66 std::vector<long>,
67 typename lock::rw::locker<lock_traits>,
68 typename lock::rw::locker<lock_traits>::decaying_write_lock_type
69 > vtr_colln_t;
70
71 typedef pool_aspects<
72 Jn,
73 platform_api,
74 Mdl,
75 pool_traits::prioritised_queue,
76 std::less,
77 GSSk
78 > thread_pool_traits;
79
80 typedef thread_pool<Db, Sz, thread_pool_traits> pool_type;
81
82 static const typename pool_type::pool_type::size_type pool_size=PoolSize;
83 };
84
85 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize, unsigned int GSSk>
86 const typename crew_priority_queue_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_type::pool_type::size_type crew_priority_queue_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_size;
87
88 typedef boost::mpl::list<
89 crew_normal_fifo_t<pool_traits::work_distribution_mode_t::worker_threads_get_work<pool_traits::work_distribution_mode_t::queue_model_t::pool_owns_queue>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
90 crew_priority_queue_t<pool_traits::work_distribution_mode_t::worker_threads_get_work<pool_traits::work_distribution_mode_t::queue_model_t::pool_owns_queue>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
91 crew_normal_fifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
92 crew_priority_queue_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
93
94
95
96 crew_normal_fifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading>,
97 crew_normal_fifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading, 0, 2>,
98 crew_priority_queue_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading>,
99 crew_priority_queue_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading, 0, 2>
100 > infinite_test_types;
101
102
103
104 template<typename T>
105 struct square : std::unary_function<T, void> {
106 static T last;
107
108 void operator()(T t) {
109 last+=t;
110 };
111 };
112
113 template<typename T>
114 T square<T>::last;
115
116 inline int sqr() {
117 static int last=0;
118 return last++<<1;
119 }
120
121 BOOST_AUTO_TEST_SUITE(thread_pool_tests)
122
123 BOOST_AUTO_TEST_SUITE(joinable_dataflow)
124
125 BOOST_AUTO_TEST_SUITE(infinite)
126
127 BOOST_AUTO_TEST_SUITE(empty_colln)
128
129 BOOST_AUTO_TEST_CASE_TEMPLATE(max_element_op, T, infinite_test_types) {
130 typedef typename T::vtr_colln_t vtr_colln_t;
131 typedef typename T::pool_type pool_type;
132 typedef typename pool_type::joinable joinable;
133
134 pool_type pool;
135 vtr_colln_t v;
136 auto const &context=pool<<joinable()<<pool.max_element(v, std::greater<typename vtr_colln_t::value_type>());
137 BOOST_CHECK_EQUAL(*context, std::numeric_limits<typename vtr_colln_t::value_type>::min());
138 BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
139 BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
140 }
141
142 BOOST_AUTO_TEST_CASE_TEMPLATE(max_element, T, infinite_test_types) {
143 typedef typename T::vtr_colln_t vtr_colln_t;
144 typedef typename T::pool_type pool_type;
145 typedef typename pool_type::joinable joinable;
146
147 pool_type pool;
148 vtr_colln_t v;
149 auto const &context=pool<<joinable()<<pool.max_element(v);
150 BOOST_CHECK_EQUAL(*context, std::numeric_limits<typename vtr_colln_t::value_type>::min());
151 BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
152 BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
153 }
154
155 BOOST_AUTO_TEST_CASE_TEMPLATE(min_element_op, T, infinite_test_types) {
156 typedef typename T::vtr_colln_t vtr_colln_t;
157 typedef typename T::pool_type pool_type;
158 typedef typename pool_type::joinable joinable;
159
160 pool_type pool;
161 vtr_colln_t v;
162 auto const &context=pool<<joinable()<<pool.min_element(v, std::greater<typename vtr_colln_t::value_type>());
163 BOOST_CHECK_EQUAL(*context, std::numeric_limits<typename vtr_colln_t::value_type>::max());
164 BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
165 BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
166 }
167
168 BOOST_AUTO_TEST_CASE_TEMPLATE(min_element, T, infinite_test_types) {
169 typedef typename T::vtr_colln_t vtr_colln_t;
170 typedef typename T::pool_type pool_type;
171 typedef typename pool_type::joinable joinable;
172
173 pool_type pool;
174 vtr_colln_t v;
175 auto const &context=pool<<joinable()<<pool.min_element(v);
176 BOOST_CHECK_EQUAL(*context, std::numeric_limits<typename vtr_colln_t::value_type>::max());
177 BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
178 BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
179 }
180
181 BOOST_AUTO_TEST_CASE_TEMPLATE(merge_op, T, infinite_test_types) {
182 typedef typename T::vtr_colln_t vtr_colln_t;
183 typedef typename T::pool_type pool_type;
184 typedef typename pool_type::joinable joinable;
185
186 pool_type pool;
187 vtr_colln_t v, v1, v_out;
188 auto const &context=pool<<joinable()<<pool.merge(v, v1, v_out, std::less<typename vtr_colln_t::value_type>());
189 pool.min_time(vtr_colln_t::memory_access_mode);
190 pool.min_processors(vtr_colln_t::memory_access_mode);
191 *context;
192 BOOST_CHECK_EQUAL(v.empty(), true);
193 BOOST_CHECK_EQUAL(v1.empty(), true);
194 BOOST_CHECK_EQUAL(v_out.size(), v.size()+v1.size());
195 BOOST_CHECK(v==v_out);
196 BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
197 BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
198 vtr_colln_t v_chk;
199 std::merge(v.colln().begin(), v.colln().end(), v1.colln().begin(), v1.colln().end(), std::back_inserter(v_chk.colln()), std::less<typename vtr_colln_t::value_type>());
200 BOOST_CHECK(v_out==v_chk);
201 }
202
203 BOOST_AUTO_TEST_CASE_TEMPLATE(merge, T, infinite_test_types) {
204 typedef typename T::vtr_colln_t vtr_colln_t;
205 typedef typename T::pool_type pool_type;
206 typedef typename pool_type::joinable joinable;
207
208 pool_type pool;
209 vtr_colln_t v, v1, v_out;
210 auto const &context=pool<<joinable()<<pool.merge(v, v1, v_out);
211 pool.min_time(vtr_colln_t::memory_access_mode);
212 pool.min_processors(vtr_colln_t::memory_access_mode);
213 *context;
214 BOOST_CHECK_EQUAL(v.empty(), true);
215 BOOST_CHECK_EQUAL(v1.empty(), true);
216 BOOST_CHECK_EQUAL(v_out.size(), v.size()+v1.size());
217 BOOST_CHECK(v==v_out);
218 BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
219 BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
220 vtr_colln_t v_chk;
221 std::merge(v.colln().begin(), v.colln().end(), v1.colln().begin(), v1.colln().end(), std::back_inserter(v_chk.colln()));
222 BOOST_CHECK(v_out==v_chk);
223 }
224
225 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_op, T, infinite_test_types) {
226 typedef typename T::vtr_colln_t vtr_colln_t;
227 typedef typename T::pool_type pool_type;
228 typedef typename pool_type::joinable joinable;
229
230 pool_type pool;
231 vtr_colln_t v;
232 vtr_colln_t v_chk(v);
233 auto const &context=pool<<joinable()<<pool.sort(v, std::greater<typename vtr_colln_t::value_type>());
234 pool.min_time(vtr_colln_t::memory_access_mode);
235 pool.min_processors(vtr_colln_t::memory_access_mode);
236 *context;
237 BOOST_CHECK_EQUAL(v.empty(), true);
238 BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
239 BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
240 std::sort(v_chk.colln().begin(), v_chk.colln().end(), std::greater<typename vtr_colln_t::value_type>());
241 BOOST_CHECK(v==v_chk);
242 }
243
244 BOOST_AUTO_TEST_CASE_TEMPLATE(sort, T, infinite_test_types) {
245 typedef typename T::vtr_colln_t vtr_colln_t;
246 typedef typename T::pool_type pool_type;
247 typedef typename pool_type::joinable joinable;
248
249 pool_type pool;
250 vtr_colln_t v;
251 vtr_colln_t v_chk(v);
252 auto const &context=pool<<joinable()<<pool.sort(v);
253 pool.min_time(vtr_colln_t::memory_access_mode);
254 pool.min_processors(vtr_colln_t::memory_access_mode);
255 *context;
256 BOOST_CHECK_EQUAL(v.empty(), true);
257 BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
258 BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
259 std::sort(v_chk.colln().begin(), v_chk.colln().end());
260 BOOST_CHECK(v==v_chk);
261 }
262
263 BOOST_AUTO_TEST_SUITE_END()
264
265 BOOST_AUTO_TEST_SUITE(nonempty_colln)
266
267 BOOST_AUTO_TEST_SUITE(one_element)
268
269 BOOST_AUTO_TEST_CASE_TEMPLATE(max_element_op, T, infinite_test_types) {
270 typedef typename T::vtr_colln_t vtr_colln_t;
271 typedef typename T::pool_type pool_type;
272 typedef typename pool_type::joinable joinable;
273
274 pool_type pool;
275 vtr_colln_t v;
276 v.push_back(1);
277 auto const &context=pool<<joinable()<<pool.max_element(v, std::greater<typename vtr_colln_t::value_type>());
278 BOOST_CHECK_EQUAL(*context, 1);
279 }
280
281 BOOST_AUTO_TEST_CASE_TEMPLATE(max_element, T, infinite_test_types) {
282 typedef typename T::vtr_colln_t vtr_colln_t;
283 typedef typename T::pool_type pool_type;
284 typedef typename pool_type::joinable joinable;
285
286 pool_type pool;
287 vtr_colln_t v;
288 v.push_back(1);
289 auto const &context=pool<<joinable()<<pool.max_element(v);
290 BOOST_CHECK_EQUAL(*context, 1);
291 }
292
293 BOOST_AUTO_TEST_CASE_TEMPLATE(min_element_op, T, infinite_test_types) {
294 typedef typename T::vtr_colln_t vtr_colln_t;
295 typedef typename T::pool_type pool_type;
296 typedef typename pool_type::joinable joinable;
297
298 pool_type pool;
299 vtr_colln_t v;
300 v.push_back(1);
301 auto const &context=pool<<joinable()<<pool.min_element(v, std::greater<typename vtr_colln_t::value_type>());
302 BOOST_CHECK_EQUAL(*context, 1);
303 }
304
305 BOOST_AUTO_TEST_CASE_TEMPLATE(min_element, T, infinite_test_types) {
306 typedef typename T::vtr_colln_t vtr_colln_t;
307 typedef typename T::pool_type pool_type;
308 typedef typename pool_type::joinable joinable;
309
310 pool_type pool;
311 vtr_colln_t v;
312 v.push_back(1);
313 auto const &context=pool<<joinable()<<pool.min_element(v);
314 BOOST_CHECK_EQUAL(*context, 1);
315 }
316
317 BOOST_AUTO_TEST_CASE_TEMPLATE(merge_op, T, infinite_test_types) {
318 typedef typename T::vtr_colln_t vtr_colln_t;
319 typedef typename T::pool_type pool_type;
320 typedef typename pool_type::joinable joinable;
321
322 pool_type pool;
323 vtr_colln_t v, v1, v_out;
324 v.push_back(1);
325 v1.push_back(1);
326 auto const &context=pool<<joinable()<<pool.merge(v, v1, v_out, std::less<typename vtr_colln_t::value_type>());
327 pool.min_time(vtr_colln_t::memory_access_mode);
328 pool.min_processors(vtr_colln_t::memory_access_mode);
329 *context;
330 BOOST_CHECK_EQUAL(v.size(), 1U);
331 BOOST_CHECK_EQUAL(v1.size(), 1U);
332 BOOST_CHECK_EQUAL(v_out.size(), v.size()+v1.size());
333 BOOST_CHECK_EQUAL(v_out[0], v[0]);
334 BOOST_CHECK_EQUAL(v_out[1], v1[0]);
335 vtr_colln_t v_chk;
336 std::merge(v.colln().begin(), v.colln().end(), v1.colln().begin(), v1.colln().end(), std::back_inserter(v_chk.colln()), std::less<typename vtr_colln_t::value_type>());
337 BOOST_CHECK(v_out==v_chk);
338 }
339
340 BOOST_AUTO_TEST_CASE_TEMPLATE(merge, T, infinite_test_types) {
341 typedef typename T::vtr_colln_t vtr_colln_t;
342 typedef typename T::pool_type pool_type;
343 typedef typename pool_type::joinable joinable;
344
345 pool_type pool;
346 vtr_colln_t v, v1, v_out;
347 v.push_back(1);
348 v1.push_back(1);
349 auto const &context=pool<<joinable()<<pool.merge(v, v1, v_out);
350 pool.min_time(vtr_colln_t::memory_access_mode);
351 pool.min_processors(vtr_colln_t::memory_access_mode);
352 *context;
353 BOOST_CHECK_EQUAL(v.size(), 1U);
354 BOOST_CHECK_EQUAL(v1.size(), 1U);
355 BOOST_CHECK_EQUAL(v_out.size(), v.size()+v1.size());
356 BOOST_CHECK_EQUAL(v_out[0], v[0]);
357 BOOST_CHECK_EQUAL(v_out[1], v1[0]);
358 vtr_colln_t v_chk;
359 std::merge(v.colln().begin(), v.colln().end(), v1.colln().begin(), v1.colln().end(), std::back_inserter(v_chk.colln()));
360 BOOST_CHECK(v_out==v_chk);
361 }
362
363 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_op, T, infinite_test_types) {
364 typedef typename T::vtr_colln_t vtr_colln_t;
365 typedef typename T::pool_type pool_type;
366 typedef typename pool_type::joinable joinable;
367
368 pool_type pool;
369 vtr_colln_t v;
370 v.push_back(1);
371 vtr_colln_t v_chk(v);
372 auto const &context=pool<<joinable()<<pool.sort(v, std::greater<typename vtr_colln_t::value_type>());
373 pool.min_time(vtr_colln_t::memory_access_mode);
374 pool.min_processors(vtr_colln_t::memory_access_mode);
375 *context;
376 BOOST_CHECK_EQUAL(v.size(), 1U);
377 BOOST_CHECK_EQUAL(v[0], 1);
378 std::sort(v_chk.colln().begin(), v_chk.colln().end(), std::greater<typename vtr_colln_t::value_type>());
379 BOOST_CHECK(v==v_chk);
380 }
381
382 BOOST_AUTO_TEST_CASE_TEMPLATE(sort, T, infinite_test_types) {
383 typedef typename T::vtr_colln_t vtr_colln_t;
384 typedef typename T::pool_type pool_type;
385 typedef typename pool_type::joinable joinable;
386
387 pool_type pool;
388 vtr_colln_t v;
389 v.push_back(1);
390 vtr_colln_t v_chk(v);
391 auto const &context=pool<<joinable()<<pool.sort(v);
392 pool.min_time(vtr_colln_t::memory_access_mode);
393 pool.min_processors(vtr_colln_t::memory_access_mode);
394 *context;
395 BOOST_CHECK_EQUAL(v.size(), 1U);
396 BOOST_CHECK_EQUAL(v[0], 1);
397 std::sort(v_chk.colln().begin(), v_chk.colln().end());
398 BOOST_CHECK(v==v_chk);
399 }
400
401 BOOST_AUTO_TEST_SUITE_END()
402
403 BOOST_AUTO_TEST_SUITE(two_elements)
404
405 BOOST_AUTO_TEST_CASE_TEMPLATE(max_element_op, T, infinite_test_types) {
406 typedef typename T::vtr_colln_t vtr_colln_t;
407 typedef typename T::pool_type pool_type;
408 typedef typename pool_type::joinable joinable;
409
410 pool_type pool;
411 vtr_colln_t v;
412 v.push_back(1);
413 v.push_back(2);
414 auto const &context=pool<<joinable()<<pool.max_element(v, std::greater<typename vtr_colln_t::value_type>());
415 BOOST_CHECK_EQUAL(*context, 1);
416 }
417
418 BOOST_AUTO_TEST_CASE_TEMPLATE(max_element, T, infinite_test_types) {
419 typedef typename T::vtr_colln_t vtr_colln_t;
420 typedef typename T::pool_type pool_type;
421 typedef typename pool_type::joinable joinable;
422
423 pool_type pool;
424 vtr_colln_t v;
425 v.push_back(1);
426 v.push_back(2);
427 auto const &context=pool<<joinable()<<pool.max_element(v);
428 BOOST_CHECK_EQUAL(*context, 2);
429 }
430
431 BOOST_AUTO_TEST_CASE_TEMPLATE(min_element_op, T, infinite_test_types) {
432 typedef typename T::vtr_colln_t vtr_colln_t;
433 typedef typename T::pool_type pool_type;
434 typedef typename pool_type::joinable joinable;
435
436 pool_type pool;
437 vtr_colln_t v;
438 v.push_back(1);
439 v.push_back(2);
440 auto const &context=pool<<joinable()<<pool.min_element(v, std::greater<typename vtr_colln_t::value_type>());
441 BOOST_CHECK_EQUAL(*context, 2);
442 }
443
444 BOOST_AUTO_TEST_CASE_TEMPLATE(min_element, T, infinite_test_types) {
445 typedef typename T::vtr_colln_t vtr_colln_t;
446 typedef typename T::pool_type pool_type;
447 typedef typename pool_type::joinable joinable;
448
449 pool_type pool;
450 vtr_colln_t v;
451 v.push_back(1);
452 v.push_back(2);
453 auto const &context=pool<<joinable()<<pool.min_element(v);
454 BOOST_CHECK_EQUAL(*context, 1);
455 }
456
457 BOOST_AUTO_TEST_CASE_TEMPLATE(merge_op, T, infinite_test_types) {
458 typedef typename T::vtr_colln_t vtr_colln_t;
459 typedef typename T::pool_type pool_type;
460 typedef typename pool_type::joinable joinable;
461
462 pool_type pool;
463 vtr_colln_t v, v1, v_out;
464 v.push_back(1);
465 v.push_back(2);
466 v1.push_back(1);
467 v1.push_back(2);
468 auto const &context=pool<<joinable()<<pool.merge(v, v1, v_out, std::less<typename vtr_colln_t::value_type>());
469 pool.min_time(vtr_colln_t::memory_access_mode);
470 pool.min_processors(vtr_colln_t::memory_access_mode);
471 *context;
472 BOOST_CHECK_EQUAL(v.size(), 2U);
473 BOOST_CHECK_EQUAL(v1.size(), 2U);
474 BOOST_CHECK_EQUAL(v_out.size(), v.size()+v1.size());
475 BOOST_CHECK_EQUAL(v_out[0], v[0]);
476 BOOST_CHECK_EQUAL(v_out[1], v1[0]);
477 BOOST_CHECK_EQUAL(v_out[2], v[1]);
478 BOOST_CHECK_EQUAL(v_out[3], v1[1]);
479 vtr_colln_t v_chk;
480 std::merge(v.colln().begin(), v.colln().end(), v1.colln().begin(), v1.colln().end(), std::back_inserter(v_chk.colln()), std::less<typename vtr_colln_t::value_type>());
481 BOOST_CHECK(v_out==v_chk);
482 }
483
484 BOOST_AUTO_TEST_CASE_TEMPLATE(merge, T, infinite_test_types) {
485 typedef typename T::vtr_colln_t vtr_colln_t;
486 typedef typename T::pool_type pool_type;
487 typedef typename pool_type::joinable joinable;
488
489 pool_type pool;
490 vtr_colln_t v, v1, v_out;
491 v.push_back(1);
492 v.push_back(2);
493 v1.push_back(1);
494 v1.push_back(2);
495 auto const &context=pool<<joinable()<<pool.merge(v, v1, v_out);
496 pool.min_time(vtr_colln_t::memory_access_mode);
497 pool.min_processors(vtr_colln_t::memory_access_mode);
498 *context;
499 BOOST_CHECK_EQUAL(v.size(), 2U);
500 BOOST_CHECK_EQUAL(v1.size(), 2U);
501 BOOST_CHECK_EQUAL(v_out.size(), v.size()+v1.size());
502 BOOST_CHECK_EQUAL(v_out[0], v[0]);
503 BOOST_CHECK_EQUAL(v_out[1], v1[0]);
504 BOOST_CHECK_EQUAL(v_out[2], v[1]);
505 BOOST_CHECK_EQUAL(v_out[3], v1[1]);
506 vtr_colln_t v_chk;
507 std::merge(v.colln().begin(), v.colln().end(), v1.colln().begin(), v1.colln().end(), std::back_inserter(v_chk.colln()));
508 BOOST_CHECK(v_out==v_chk);
509 }
510
511 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_op_sorted, T, infinite_test_types) {
512 typedef typename T::vtr_colln_t vtr_colln_t;
513 typedef typename T::pool_type pool_type;
514 typedef typename pool_type::joinable joinable;
515
516 pool_type pool;
517 vtr_colln_t v;
518 v.push_back(1);
519 v.push_back(2);
520 vtr_colln_t v_chk(v);
521 auto const &context=pool<<joinable()<<pool.sort(v, std::greater<typename vtr_colln_t::value_type>());
522 pool.min_time(vtr_colln_t::memory_access_mode);
523 pool.min_processors(vtr_colln_t::memory_access_mode);
524 *context;
525 BOOST_CHECK_EQUAL(v.size(), 2U);
526 BOOST_CHECK_EQUAL(v[0], 2);
527 BOOST_CHECK_EQUAL(v[1], 1);
528 std::sort(v_chk.colln().begin(), v_chk.colln().end(), std::greater<typename vtr_colln_t::value_type>());
529 BOOST_CHECK(v==v_chk);
530 }
531
532 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_op_unsorted, T, infinite_test_types) {
533 typedef typename T::vtr_colln_t vtr_colln_t;
534 typedef typename T::pool_type pool_type;
535 typedef typename pool_type::joinable joinable;
536
537 pool_type pool;
538 vtr_colln_t v;
539 v.push_back(2);
540 v.push_back(1);
541 vtr_colln_t v_chk(v);
542 auto const &context=pool<<joinable()<<pool.sort(v, std::greater<typename vtr_colln_t::value_type>());
543 pool.min_time(vtr_colln_t::memory_access_mode);
544 pool.min_processors(vtr_colln_t::memory_access_mode);
545 *context;
546 BOOST_CHECK_EQUAL(v.size(), 2U);
547 BOOST_CHECK_EQUAL(v[0], 2);
548 BOOST_CHECK_EQUAL(v[1], 1);
549 std::sort(v_chk.colln().begin(), v_chk.colln().end(), std::greater<typename vtr_colln_t::value_type>());
550 BOOST_CHECK(v==v_chk);
551 }
552
553 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_sorted, T, infinite_test_types) {
554 typedef typename T::vtr_colln_t vtr_colln_t;
555 typedef typename T::pool_type pool_type;
556 typedef typename pool_type::joinable joinable;
557
558 pool_type pool;
559 vtr_colln_t v;
560 v.push_back(1);
561 v.push_back(2);
562 vtr_colln_t v_chk(v);
563 auto const &context=pool<<joinable()<<pool.sort(v);
564 pool.min_time(vtr_colln_t::memory_access_mode);
565 pool.min_processors(vtr_colln_t::memory_access_mode);
566 *context;
567 BOOST_CHECK_EQUAL(v.size(), 2U);
568 BOOST_CHECK_EQUAL(v[0], 1);
569 BOOST_CHECK_EQUAL(v[1], 2);
570 std::sort(v_chk.colln().begin(), v_chk.colln().end());
571 BOOST_CHECK(v==v_chk);
572 }
573
574 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_unsorted, T, infinite_test_types) {
575 typedef typename T::vtr_colln_t vtr_colln_t;
576 typedef typename T::pool_type pool_type;
577 typedef typename pool_type::joinable joinable;
578
579 pool_type pool;
580 vtr_colln_t v;
581 v.push_back(2);
582 v.push_back(1);
583 vtr_colln_t v_chk(v);
584 auto const &context=pool<<joinable()<<pool.sort(v);
585 pool.min_time(vtr_colln_t::memory_access_mode);
586 pool.min_processors(vtr_colln_t::memory_access_mode);
587 *context;
588 BOOST_CHECK_EQUAL(v.size(), 2U);
589 BOOST_CHECK_EQUAL(v[0], 1);
590 BOOST_CHECK_EQUAL(v[1], 2);
591 std::sort(v_chk.colln().begin(), v_chk.colln().end());
592 BOOST_CHECK(v==v_chk);
593 }
594
595 BOOST_AUTO_TEST_SUITE_END()
596
597 BOOST_AUTO_TEST_SUITE(n_elements)
598
599 BOOST_AUTO_TEST_CASE_TEMPLATE(max_element_op, T, infinite_test_types) {
600 typedef typename T::vtr_colln_t vtr_colln_t;
601 typedef typename T::pool_type pool_type;
602 typedef typename pool_type::joinable joinable;
603
604 pool_type pool;
605 vtr_colln_t v;
606 v.push_back(1);
607 v.push_back(2);
608 v.push_back(3);
609 v.push_back(4);
610 v.push_back(5);
611 v.push_back(6);
612 v.push_back(7);
613 v.push_back(8);
614 auto const &context=pool<<joinable()<<pool.max_element(v, std::greater<typename vtr_colln_t::value_type>());
615 BOOST_CHECK_EQUAL(*context, 1);
616 }
617
618 BOOST_AUTO_TEST_CASE_TEMPLATE(max_element, T, infinite_test_types) {
619 typedef typename T::vtr_colln_t vtr_colln_t;
620 typedef typename T::pool_type pool_type;
621 typedef typename pool_type::joinable joinable;
622
623 pool_type pool;
624 vtr_colln_t v;
625 v.push_back(1);
626 v.push_back(2);
627 v.push_back(3);
628 v.push_back(4);
629 v.push_back(5);
630 v.push_back(6);
631 v.push_back(7);
632 v.push_back(8);
633 auto const &context=pool<<joinable()<<pool.max_element(v);
634 BOOST_CHECK_EQUAL(*context, 8);
635 }
636
637 BOOST_AUTO_TEST_CASE_TEMPLATE(min_element_op, T, infinite_test_types) {
638 typedef typename T::vtr_colln_t vtr_colln_t;
639 typedef typename T::pool_type pool_type;
640 typedef typename pool_type::joinable joinable;
641
642 pool_type pool;
643 vtr_colln_t v;
644 v.push_back(1);
645 v.push_back(2);
646 v.push_back(3);
647 v.push_back(4);
648 v.push_back(5);
649 v.push_back(6);
650 v.push_back(7);
651 v.push_back(8);
652 auto const &context=pool<<joinable()<<pool.min_element(v, std::greater<typename vtr_colln_t::value_type>());
653 BOOST_CHECK_EQUAL(*context, 8);
654 }
655
656 BOOST_AUTO_TEST_CASE_TEMPLATE(min_element, T, infinite_test_types) {
657 typedef typename T::vtr_colln_t vtr_colln_t;
658 typedef typename T::pool_type pool_type;
659 typedef typename pool_type::joinable joinable;
660
661 pool_type pool;
662 vtr_colln_t v;
663 v.push_back(1);
664 v.push_back(2);
665 v.push_back(3);
666 v.push_back(4);
667 v.push_back(5);
668 v.push_back(6);
669 v.push_back(7);
670 v.push_back(8);
671 auto const &context=pool<<joinable()<<pool.min_element(v);
672 BOOST_CHECK_EQUAL(*context, 1);
673 }
674
675 BOOST_AUTO_TEST_CASE_TEMPLATE(merge_op, T, infinite_test_types) {
676 typedef typename T::vtr_colln_t vtr_colln_t;
677 typedef typename T::pool_type pool_type;
678 typedef typename pool_type::joinable joinable;
679
680 pool_type pool;
681 vtr_colln_t v, v1, v_out;
682 v.push_back(1);
683 v.push_back(3);
684 v.push_back(5);
685 v.push_back(7);
686 v.push_back(9);
687 v.push_back(11);
688 v.push_back(13);
689 v.push_back(15);
690 v1.push_back(2);
691 v1.push_back(4);
692 v1.push_back(6);
693 v1.push_back(8);
694 v1.push_back(10);
695 v1.push_back(12);
696 v1.push_back(14);
697 v1.push_back(16);
698 auto const &context=pool<<joinable()<<pool.merge(v, v1, v_out, std::less<typename vtr_colln_t::value_type>());
699 pool.min_time(vtr_colln_t::memory_access_mode);
700 pool.min_processors(vtr_colln_t::memory_access_mode);
701 *context;
702 BOOST_CHECK_EQUAL(v.size(), 8U);
703 BOOST_CHECK_EQUAL(v1.size(), 8U);
704 BOOST_CHECK_EQUAL(v_out.size(), v.size()+v1.size());
705 BOOST_CHECK_EQUAL(v_out[0], v[0]);
706 BOOST_CHECK_EQUAL(v_out[1], v1[0]);
707 BOOST_CHECK_EQUAL(v_out[2], v[1]);
708 BOOST_CHECK_EQUAL(v_out[3], v1[1]);
709 BOOST_CHECK_EQUAL(v_out[4], v[2]);
710 BOOST_CHECK_EQUAL(v_out[5], v1[2]);
711 BOOST_CHECK_EQUAL(v_out[6], v[3]);
712 BOOST_CHECK_EQUAL(v_out[7], v1[3]);
713 BOOST_CHECK_EQUAL(v_out[8], v[4]);
714 BOOST_CHECK_EQUAL(v_out[9], v1[4]);
715 BOOST_CHECK_EQUAL(v_out[10], v[5]);
716 BOOST_CHECK_EQUAL(v_out[11], v1[5]);
717 BOOST_CHECK_EQUAL(v_out[12], v[6]);
718 BOOST_CHECK_EQUAL(v_out[13], v1[6]);
719 BOOST_CHECK_EQUAL(v_out[14], v[7]);
720 BOOST_CHECK_EQUAL(v_out[15], v1[7]);
721 vtr_colln_t v_chk;
722 std::merge(v.colln().begin(), v.colln().end(), v1.colln().begin(), v1.colln().end(), std::back_inserter(v_chk.colln()), std::less<typename vtr_colln_t::value_type>());
723 BOOST_CHECK(v_out==v_chk);
724 }
725
726 BOOST_AUTO_TEST_CASE_TEMPLATE(merge, T, infinite_test_types) {
727 typedef typename T::vtr_colln_t vtr_colln_t;
728 typedef typename T::pool_type pool_type;
729 typedef typename pool_type::joinable joinable;
730
731 pool_type pool;
732 vtr_colln_t v, v1, v_out;
733 v.push_back(1);
734 v.push_back(3);
735 v.push_back(5);
736 v.push_back(7);
737 v.push_back(9);
738 v.push_back(11);
739 v.push_back(13);
740 v.push_back(15);
741 v1.push_back(2);
742 v1.push_back(4);
743 v1.push_back(6);
744 v1.push_back(8);
745 v1.push_back(10);
746 v1.push_back(12);
747 v1.push_back(14);
748 v1.push_back(16);
749 auto const &context=pool<<joinable()<<pool.merge(v, v1, v_out);
750 pool.min_time(vtr_colln_t::memory_access_mode);
751 pool.min_processors(vtr_colln_t::memory_access_mode);
752 *context;
753 BOOST_CHECK_EQUAL(v.size(), 8U);
754 BOOST_CHECK_EQUAL(v1.size(), 8U);
755 BOOST_CHECK_EQUAL(v_out.size(), v.size()+v1.size());
756 BOOST_CHECK_EQUAL(v_out[0], v[0]);
757 BOOST_CHECK_EQUAL(v_out[1], v1[0]);
758 BOOST_CHECK_EQUAL(v_out[2], v[1]);
759 BOOST_CHECK_EQUAL(v_out[3], v1[1]);
760 BOOST_CHECK_EQUAL(v_out[4], v[2]);
761 BOOST_CHECK_EQUAL(v_out[5], v1[2]);
762 BOOST_CHECK_EQUAL(v_out[6], v[3]);
763 BOOST_CHECK_EQUAL(v_out[7], v1[3]);
764 BOOST_CHECK_EQUAL(v_out[8], v[4]);
765 BOOST_CHECK_EQUAL(v_out[9], v1[4]);
766 BOOST_CHECK_EQUAL(v_out[10], v[5]);
767 BOOST_CHECK_EQUAL(v_out[11], v1[5]);
768 BOOST_CHECK_EQUAL(v_out[12], v[6]);
769 BOOST_CHECK_EQUAL(v_out[13], v1[6]);
770 BOOST_CHECK_EQUAL(v_out[14], v[7]);
771 BOOST_CHECK_EQUAL(v_out[15], v1[7]);
772 vtr_colln_t v_chk;
773 std::merge(v.colln().begin(), v.colln().end(), v1.colln().begin(), v1.colln().end(), std::back_inserter(v_chk.colln()));
774 BOOST_CHECK(v_out==v_chk);
775 }
776
777 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_op_sorted, T, infinite_test_types) {
778 typedef typename T::vtr_colln_t vtr_colln_t;
779 typedef typename T::pool_type pool_type;
780 typedef typename pool_type::joinable joinable;
781
782 pool_type pool;
783 vtr_colln_t v;
784 v.push_back(1);
785 v.push_back(2);
786 v.push_back(3);
787 v.push_back(4);
788 v.push_back(5);
789 v.push_back(6);
790 v.push_back(7);
791 v.push_back(8);
792 vtr_colln_t v_chk(v);
793 auto const &context=pool<<joinable()<<pool.sort(v, std::greater<typename vtr_colln_t::value_type>());
794 pool.min_time(vtr_colln_t::memory_access_mode);
795 pool.min_processors(vtr_colln_t::memory_access_mode);
796 *context;
797 BOOST_CHECK_EQUAL(v.size(), 8U);
798 BOOST_CHECK_EQUAL(v[0], 8);
799 BOOST_CHECK_EQUAL(v[1], 7);
800 BOOST_CHECK_EQUAL(v[2], 6);
801 BOOST_CHECK_EQUAL(v[3], 5);
802 BOOST_CHECK_EQUAL(v[4], 4);
803 BOOST_CHECK_EQUAL(v[5], 3);
804 BOOST_CHECK_EQUAL(v[6], 2);
805 BOOST_CHECK_EQUAL(v[7], 1);
806 std::sort(v_chk.colln().begin(), v_chk.colln().end(), std::greater<typename vtr_colln_t::value_type>());
807 BOOST_CHECK(v==v_chk);
808 }
809
810 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_op_unsorted, T, infinite_test_types) {
811 typedef typename T::vtr_colln_t vtr_colln_t;
812 typedef typename T::pool_type pool_type;
813 typedef typename pool_type::joinable joinable;
814
815 pool_type pool;
816 vtr_colln_t v;
817 v.push_back(8);
818 v.push_back(7);
819 v.push_back(6);
820 v.push_back(5);
821 v.push_back(4);
822 v.push_back(3);
823 v.push_back(2);
824 v.push_back(1);
825 vtr_colln_t v_chk(v);
826 auto const &context=pool<<joinable()<<pool.sort(v, std::greater<typename vtr_colln_t::value_type>());
827 pool.min_time(vtr_colln_t::memory_access_mode);
828 pool.min_processors(vtr_colln_t::memory_access_mode);
829 *context;
830 BOOST_CHECK_EQUAL(v.size(), 8U);
831 BOOST_CHECK_EQUAL(v[0], 8);
832 BOOST_CHECK_EQUAL(v[1], 7);
833 BOOST_CHECK_EQUAL(v[2], 6);
834 BOOST_CHECK_EQUAL(v[3], 5);
835 BOOST_CHECK_EQUAL(v[4], 4);
836 BOOST_CHECK_EQUAL(v[5], 3);
837 BOOST_CHECK_EQUAL(v[6], 2);
838 BOOST_CHECK_EQUAL(v[7], 1);
839 std::sort(v_chk.colln().begin(), v_chk.colln().end(), std::greater<typename vtr_colln_t::value_type>());
840 BOOST_CHECK(v==v_chk);
841 }
842
843 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_sorted, T, infinite_test_types) {
844 typedef typename T::vtr_colln_t vtr_colln_t;
845 typedef typename T::pool_type pool_type;
846 typedef typename pool_type::joinable joinable;
847
848 pool_type pool;
849 vtr_colln_t v;
850 v.push_back(1);
851 v.push_back(2);
852 v.push_back(3);
853 v.push_back(4);
854 v.push_back(5);
855 v.push_back(6);
856 v.push_back(7);
857 v.push_back(8);
858 vtr_colln_t v_chk(v);
859 auto const &context=pool<<joinable()<<pool.sort(v);
860 pool.min_time(vtr_colln_t::memory_access_mode);
861 pool.min_processors(vtr_colln_t::memory_access_mode);
862 *context;
863 BOOST_CHECK_EQUAL(v.size(), 8U);
864 BOOST_CHECK_EQUAL(v[0], 1);
865 BOOST_CHECK_EQUAL(v[1], 2);
866 BOOST_CHECK_EQUAL(v[2], 3);
867 BOOST_CHECK_EQUAL(v[3], 4);
868 BOOST_CHECK_EQUAL(v[4], 5);
869 BOOST_CHECK_EQUAL(v[5], 6);
870 BOOST_CHECK_EQUAL(v[6], 7);
871 BOOST_CHECK_EQUAL(v[7], 8);
872 std::sort(v_chk.colln().begin(), v_chk.colln().end());
873 BOOST_CHECK(v==v_chk);
874 }
875
876 BOOST_AUTO_TEST_CASE_TEMPLATE(sort_unsorted, T, infinite_test_types) {
877 typedef typename T::vtr_colln_t vtr_colln_t;
878 typedef typename T::pool_type pool_type;
879 typedef typename pool_type::joinable joinable;
880
881 pool_type pool;
882 vtr_colln_t v;
883 v.push_back(8);
884 v.push_back(7);
885 v.push_back(6);
886 v.push_back(5);
887 v.push_back(4);
888 v.push_back(3);
889 v.push_back(2);
890 v.push_back(1);
891 vtr_colln_t v_chk(v);
892 auto const &context=pool<<joinable()<<pool.sort(v);
893 pool.min_time(vtr_colln_t::memory_access_mode);
894 pool.min_processors(vtr_colln_t::memory_access_mode);
895 *context;
896 BOOST_CHECK_EQUAL(v.size(), 8U);
897 BOOST_CHECK_EQUAL(v[0], 1);
898 BOOST_CHECK_EQUAL(v[1], 2);
899 BOOST_CHECK_EQUAL(v[2], 3);
900 BOOST_CHECK_EQUAL(v[3], 4);
901 BOOST_CHECK_EQUAL(v[4], 5);
902 BOOST_CHECK_EQUAL(v[5], 6);
903 BOOST_CHECK_EQUAL(v[6], 7);
904 BOOST_CHECK_EQUAL(v[7], 8);
905 std::sort(v_chk.colln().begin(), v_chk.colln().end());
906 BOOST_CHECK(v==v_chk);
907 }
908
909 BOOST_AUTO_TEST_SUITE_END()
910
911 BOOST_AUTO_TEST_SUITE_END()
912
913 BOOST_AUTO_TEST_SUITE_END()
914
915 BOOST_AUTO_TEST_SUITE_END()
916
917 BOOST_AUTO_TEST_SUITE_END()