root/examples/dataflow_full_sorting_algos_finite_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_finite_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 
  92         crew_normal_fifo_t<pool_traits::work_distribution_mode_t::worker_threads_get_work<pool_traits::work_distribution_mode_t::queue_model_t::pool_owns_queue>, pool_traits::size_mode_t::fixed_size, generic_traits::return_data::joinable, heavyweight_threading, 1>,
  93 // 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>,

  94         crew_priority_queue_t<pool_traits::work_distribution_mode_t::worker_threads_get_work<pool_traits::work_distribution_mode_t::queue_model_t::pool_owns_queue>, pool_traits::size_mode_t::fixed_size, generic_traits::return_data::joinable, heavyweight_threading, 1>,
  95 // 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>,

  96 
  97         crew_normal_fifo_t<pool_traits::work_distribution_mode_t::worker_threads_get_work<pool_traits::work_distribution_mode_t::queue_model_t::pool_owns_queue>, pool_traits::size_mode_t::fixed_size, generic_traits::return_data::joinable, heavyweight_threading, 2>,
  98         crew_priority_queue_t<pool_traits::work_distribution_mode_t::worker_threads_get_work<pool_traits::work_distribution_mode_t::queue_model_t::pool_owns_queue>, pool_traits::size_mode_t::fixed_size, generic_traits::return_data::joinable, heavyweight_threading, 2>
  99 > finite_test_types;
 100 
 101 // TODO Need to test: pool_traits::size_mode_t::tracks_to_max

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

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