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