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