root/examples/dataflow_full_sorting_algos_infinite_crew.cpp

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. sqr
  2. BOOST_AUTO_TEST_SUITE
  3. BOOST_AUTO_TEST_CASE_TEMPLATE
  4. BOOST_AUTO_TEST_CASE_TEMPLATE
  5. BOOST_AUTO_TEST_CASE_TEMPLATE
  6. BOOST_AUTO_TEST_CASE_TEMPLATE
  7. BOOST_AUTO_TEST_CASE_TEMPLATE
  8. BOOST_AUTO_TEST_CASE_TEMPLATE
  9. BOOST_AUTO_TEST_CASE_TEMPLATE
  10. BOOST_AUTO_TEST_SUITE_END
  11. BOOST_AUTO_TEST_CASE_TEMPLATE
  12. BOOST_AUTO_TEST_CASE_TEMPLATE
  13. BOOST_AUTO_TEST_CASE_TEMPLATE
  14. BOOST_AUTO_TEST_CASE_TEMPLATE
  15. BOOST_AUTO_TEST_CASE_TEMPLATE
  16. BOOST_AUTO_TEST_CASE_TEMPLATE
  17. BOOST_AUTO_TEST_CASE_TEMPLATE
  18. BOOST_AUTO_TEST_SUITE_END
  19. BOOST_AUTO_TEST_CASE_TEMPLATE
  20. BOOST_AUTO_TEST_CASE_TEMPLATE
  21. BOOST_AUTO_TEST_CASE_TEMPLATE
  22. BOOST_AUTO_TEST_CASE_TEMPLATE
  23. BOOST_AUTO_TEST_CASE_TEMPLATE
  24. BOOST_AUTO_TEST_CASE_TEMPLATE
  25. BOOST_AUTO_TEST_CASE_TEMPLATE
  26. BOOST_AUTO_TEST_CASE_TEMPLATE
  27. BOOST_AUTO_TEST_CASE_TEMPLATE
  28. BOOST_AUTO_TEST_SUITE_END
  29. BOOST_AUTO_TEST_CASE_TEMPLATE
  30. BOOST_AUTO_TEST_CASE_TEMPLATE
  31. BOOST_AUTO_TEST_CASE_TEMPLATE
  32. BOOST_AUTO_TEST_CASE_TEMPLATE
  33. BOOST_AUTO_TEST_CASE_TEMPLATE
  34. BOOST_AUTO_TEST_CASE_TEMPLATE
  35. BOOST_AUTO_TEST_CASE_TEMPLATE
  36. BOOST_AUTO_TEST_CASE_TEMPLATE
  37. BOOST_AUTO_TEST_CASE_TEMPLATE

   1 /******************************************************************************

   2 ** $Header: svn+ssh://jmmcg@svn.code.sf.net/p/libjmmcg/code/trunk/libjmmcg/examples/dataflow_full_sorting_algos_infinite_crew.cpp 2185 2017-10-13 10:14:17Z jmmcg $

   3 **

   4 ** Copyright © 2002 by J.M.McGuiness, coder@hussar.me.uk

   5 **

   6 ** This library is free software; you can redistribute it and/or

   7 ** modify it under the terms of the GNU Lesser General Public

   8 ** License as published by the Free Software Foundation; either

   9 ** version 2.1 of the License, or (at your option) any later version.

  10 **

  11 ** This library is distributed in the hope that it will be useful,

  12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of

  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

  14 ** Lesser General Public License for more details.

  15 **

  16 ** You should have received a copy of the GNU Lesser General Public

  17 ** License along with this library; if not, write to the Free Software

  18 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  19 */
  20 
  21 #include "stdafx.h"
  22 
  23 #define BOOST_TEST_MODULE libjmmcg_tests
  24 #include <boost/test/included/unit_test.hpp>
  25 
  26 #include <boost/test/test_case_template.hpp>
  27 #include <boost/mpl/list.hpp>
  28 
  29 #include "core/thread_pool_sequential.hpp"
  30 #include "core/thread_pool_master.hpp"
  31 #include "core/thread_pool_workers.hpp"
  32 
  33 using namespace jmmcg;
  34 using namespace jmmcg::ppd;
  35 
  36 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize=0, unsigned int GSSk=1>
  37 struct crew_normal_fifo_t {
  38         typedef api_lock_traits<platform_api, Mdl> lock_traits;
  39         typedef safe_colln<
  40                 std::vector<long>,
  41                 typename lock::rw::locker<lock_traits>,
  42                 typename lock::rw::locker<lock_traits>::decaying_write_lock_type
  43         > vtr_colln_t;
  44 
  45         typedef pool_aspects<
  46                 Jn,
  47                 platform_api,
  48                 Mdl,
  49                 pool_traits::normal_fifo,
  50                 std::less,
  51                 GSSk
  52         > thread_pool_traits;
  53 
  54         typedef thread_pool<Db, Sz, thread_pool_traits> pool_type;
  55 
  56         static const typename pool_type::pool_type::size_type pool_size=PoolSize;
  57 };
  58 
  59 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize, unsigned int GSSk>
  60 const typename crew_normal_fifo_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_type::pool_type::size_type crew_normal_fifo_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_size;
  61 
  62 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize=0, unsigned int GSSk=1>
  63 struct crew_priority_queue_t {
  64         typedef api_lock_traits<platform_api, Mdl> lock_traits;
  65         typedef safe_colln<
  66                 std::vector<long>,
  67                 typename lock::rw::locker<lock_traits>,
  68                 typename lock::rw::locker<lock_traits>::decaying_write_lock_type
  69         > vtr_colln_t;
  70 
  71         typedef pool_aspects<
  72                 Jn,
  73                 platform_api,
  74                 Mdl,
  75                 pool_traits::prioritised_queue,
  76                 std::less,
  77                 GSSk
  78         > thread_pool_traits;
  79 
  80         typedef thread_pool<Db, Sz, thread_pool_traits> pool_type;
  81 
  82         static const typename pool_type::pool_type::size_type pool_size=PoolSize;
  83 };
  84 
  85 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize, unsigned int GSSk>
  86 const typename crew_priority_queue_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_type::pool_type::size_type crew_priority_queue_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_size;
  87 
  88 typedef boost::mpl::list<
  89         crew_normal_fifo_t<pool_traits::work_distribution_mode_t::worker_threads_get_work<pool_traits::work_distribution_mode_t::queue_model_t::pool_owns_queue>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
  90         crew_priority_queue_t<pool_traits::work_distribution_mode_t::worker_threads_get_work<pool_traits::work_distribution_mode_t::queue_model_t::pool_owns_queue>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
  91         crew_normal_fifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
  92         crew_priority_queue_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
  93 
  94 // 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::infinite, generic_traits::return_data::joinable, heavyweight_threading>,

  95 // 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::infinite, generic_traits::return_data::joinable, heavyweight_threading>,

  96         crew_normal_fifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading>,
  97         crew_normal_fifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading, 0, 2>,
  98         crew_priority_queue_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading>,
  99         crew_priority_queue_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading, 0, 2>
 100 > infinite_test_types;
 101 
 102 // TODO Need to test: pool_traits::size_mode_t::tracks_to_max

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

/* [<][>][^][v][top][bottom][index][help] */