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