libjmmcg  release_579_6_g8cffd
A C++ library containing an eclectic mix of useful, advanced components.
dataflow_full_mutating_algos.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_normal_lifo_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::normal_lifo,
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_normal_lifo_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_type::pool_type::size_type erew_normal_lifo_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_size;
82 
83 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize=0, unsigned int GSSk=1>
84 struct erew_priority_queue_t {
85  typedef api_lock_traits<platform_api, Mdl> lock_traits;
86  typedef safe_colln<
87  std::vector<long>,
88  typename lock_traits::nonrecursive_anon_mutex_type
89  > vtr_colln_t;
90 
91  typedef pool_aspects<
92  Jn,
93  platform_api,
94  Mdl,
95  pool_traits::prioritised_queue,
96  std::less,
97  GSSk
98  > thread_pool_traits;
99 
100  typedef thread_pool<Db, Sz, thread_pool_traits> pool_type;
101 
102  static const typename pool_type::pool_type::size_type pool_size=PoolSize;
103 };
104 
105 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize, unsigned int GSSk>
106 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;
107 
108 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize=0, unsigned int GSSk=1>
109 struct crew_normal_fifo_t {
110  typedef api_lock_traits<platform_api, Mdl> lock_traits;
111  typedef safe_colln<
112  std::vector<long>,
113  typename lock::rw::locker<lock_traits>,
114  typename lock::rw::locker<lock_traits>::decaying_write_lock_type
115  > vtr_colln_t;
116 
117  typedef pool_aspects<
118  Jn,
119  platform_api,
120  Mdl,
121  pool_traits::normal_fifo,
122  std::less,
123  GSSk
124  > thread_pool_traits;
125 
126  typedef thread_pool<Db, Sz, thread_pool_traits> pool_type;
127 
128  static const typename pool_type::pool_type::size_type pool_size=PoolSize;
129 };
130 
131 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize, unsigned int GSSk>
132 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;
133 
134 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize=0, unsigned int GSSk=1>
135 struct crew_normal_lifo_t {
136  typedef api_lock_traits<platform_api, Mdl> lock_traits;
137  typedef safe_colln<
138  std::vector<long>,
139  typename lock::rw::locker<lock_traits>,
140  typename lock::rw::locker<lock_traits>::decaying_write_lock_type
141  > vtr_colln_t;
142 
143  typedef pool_aspects<
144  Jn,
145  platform_api,
146  Mdl,
147  pool_traits::normal_lifo,
148  std::less,
149  GSSk
150  > thread_pool_traits;
151 
152  typedef thread_pool<Db, Sz, thread_pool_traits> pool_type;
153 
154  static const typename pool_type::pool_type::size_type pool_size=PoolSize;
155 };
156 
157 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize, unsigned int GSSk>
158 const typename crew_normal_lifo_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_type::pool_type::size_type crew_normal_lifo_t<Db, Sz, Jn, Mdl, PoolSize, GSSk>::pool_size;
159 
160 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize=0, unsigned int GSSk=1>
161 struct crew_priority_queue_t {
162  typedef api_lock_traits<platform_api, Mdl> lock_traits;
163  typedef safe_colln<
164  std::vector<long>,
165  typename lock::rw::locker<lock_traits>,
166  typename lock::rw::locker<lock_traits>::decaying_write_lock_type
167  > vtr_colln_t;
168 
169  typedef pool_aspects<
170  Jn,
171  platform_api,
172  Mdl,
173  pool_traits::prioritised_queue,
174  std::less,
175  GSSk
176  > thread_pool_traits;
177 
178  typedef thread_pool<Db, Sz, thread_pool_traits> pool_type;
179 
180  static const typename pool_type::pool_type::size_type pool_size=PoolSize;
181 };
182 
183 template<class Db, pool_traits::size_mode_t Sz, generic_traits::return_data Jn, class Mdl, unsigned int PoolSize, unsigned int GSSk>
184 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;
185 
186 typedef boost::mpl::list<
187  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>,
188  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>,
189  erew_normal_lifo_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>,
190  crew_normal_lifo_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>,
191  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>,
192  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>,
193 
194  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>,
195 // 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>,
196  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>,
197 // 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>,
198  erew_normal_lifo_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>,
199 // TODO erew_normal_lifo_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>,
200  crew_normal_lifo_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>,
201 // TODO crew_normal_lifo_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>,
202  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>,
203 // 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>,
204  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>,
205 // 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>,
206 
207  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>,
208  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>,
209  erew_normal_lifo_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>,
210  crew_normal_lifo_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>,
211  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>,
212  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>
213 > finite_test_types;
214 
215 typedef boost::mpl::list<
216  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>,
217  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>,
218  erew_normal_lifo_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>,
219  crew_normal_lifo_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>,
220  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>,
221  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>,
222  erew_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>,
223  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>,
224  erew_normal_lifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
225  crew_normal_lifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::sequential, generic_traits::return_data::joinable, sequential_mode>,
226  erew_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>,
227  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>,
228 
229 // 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::infinite, generic_traits::return_data::joinable, heavyweight_threading>,
230 // 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>,
231 // TODO erew_normal_lifo_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>,
232 // TODO crew_normal_lifo_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>,
233 // 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::infinite, generic_traits::return_data::joinable, heavyweight_threading>,
234 // 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>,
235  erew_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>,
236  erew_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>,
237  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>,
238  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>,
239  erew_normal_lifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading>,
240  erew_normal_lifo_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>,
241  crew_normal_lifo_t<pool_traits::work_distribution_mode_t::one_thread_distributes<>, pool_traits::size_mode_t::infinite, generic_traits::return_data::joinable, heavyweight_threading>,
242  crew_normal_lifo_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>,
243  erew_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>,
244  erew_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>,
245  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>,
246  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>
247 > infinite_test_types;
248 
249 // TODO Need to test: pool_traits::size_mode_t::tracks_to_max
250 
251 template<typename T>
252 struct square : std::unary_function<T, void> {
253  static T last;
254 
255  void operator()(T t) {
256  last+=t;
257  };
258 };
259 
260 template<typename T>
261 T square<T>::last;
262 
263 inline int sqr() {
264  static int last=0;
265  return last++<<1;
266 }
267 
268 BOOST_AUTO_TEST_SUITE(thread_pool_tests)
269 
270 BOOST_AUTO_TEST_SUITE(joinable_dataflow)
271 
272 BOOST_AUTO_TEST_SUITE(finite)
273 
274 BOOST_AUTO_TEST_SUITE(empty_colln)
275 
276 BOOST_AUTO_TEST_CASE_TEMPLATE(transform, T, finite_test_types) {
277  typedef typename T::vtr_colln_t vtr_colln_t;
278  typedef typename T::pool_type pool_type;
279  typedef typename pool_type::joinable joinable;
280 
281  pool_type pool(T::pool_size);
282  vtr_colln_t v, v_out;
283  auto const &context=pool<<joinable()<<pool.transform(v, v_out, std::negate<typename vtr_colln_t::value_type>());
284  pool.min_time(vtr_colln_t::memory_access_mode);
285  pool.min_processors(vtr_colln_t::memory_access_mode);
286  *context;
287  BOOST_CHECK_EQUAL(v.empty(), true);
288  BOOST_CHECK(v==v_out);
289  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
290  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
291 }
292 
293 BOOST_AUTO_TEST_CASE_TEMPLATE(transform_2_collns, T, finite_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(T::pool_size);
299  vtr_colln_t v, v1, v_out;
300  auto const &context=pool<<joinable()<<pool.transform(v, v1, v_out, std::plus<typename vtr_colln_t::value_type>());
301  pool.min_time(vtr_colln_t::memory_access_mode);
302  pool.min_processors(vtr_colln_t::memory_access_mode);
303  *context;
304  BOOST_CHECK_EQUAL(v.empty(), true);
305  BOOST_CHECK_EQUAL(v1.empty(), true);
306  BOOST_CHECK(v==v_out);
307  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
308  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
309 }
310 
311 BOOST_AUTO_TEST_CASE_TEMPLATE(copy, 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, v_out;
318  auto const &context=pool<<joinable()<<pool.copy(v, v_out);
319  pool.min_time(vtr_colln_t::memory_access_mode);
320  pool.min_processors(vtr_colln_t::memory_access_mode);
321  *context;
322  BOOST_CHECK_EQUAL(v.empty(), true);
323  BOOST_CHECK_EQUAL(v.size(), 0U);
324  BOOST_CHECK(v==v_out);
325  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
326  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
327 }
328 
329 BOOST_AUTO_TEST_CASE_TEMPLATE(fill_n, T, finite_test_types) {
330  typedef typename T::vtr_colln_t vtr_colln_t;
331  typedef typename T::pool_type pool_type;
332  typedef typename pool_type::joinable joinable;
333 
334  pool_type pool(T::pool_size);
335  vtr_colln_t v;
336  auto const &context=pool<<joinable()<<pool.fill_n(v, 1, typename vtr_colln_t::value_type(1));
337  *context;
338  BOOST_CHECK_EQUAL(v.empty(), false);
339  BOOST_CHECK_EQUAL(v.size(), 1);
340  BOOST_CHECK_EQUAL(v[0], 1);
341  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
342  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
343 }
344 
345 BOOST_AUTO_TEST_CASE_TEMPLATE(fill, T, finite_test_types) {
346  typedef typename T::vtr_colln_t vtr_colln_t;
347  typedef typename T::pool_type pool_type;
348  typedef typename pool_type::joinable joinable;
349 
350  pool_type pool(T::pool_size);
351  vtr_colln_t v;
352  auto const &context=pool<<joinable()<<pool.fill(v, typename vtr_colln_t::value_type(1));
353  *context;
354  BOOST_CHECK_EQUAL(v.empty(), true);
355  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
356  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
357 }
358 
359 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse, T, finite_test_types) {
360  typedef typename T::vtr_colln_t vtr_colln_t;
361  typedef typename T::pool_type pool_type;
362  typedef typename pool_type::joinable joinable;
363 
364  pool_type pool(T::pool_size);
365  vtr_colln_t v;
366  auto const &context=pool<<joinable()<<pool.reverse(v);
367  *context;
368  BOOST_CHECK_EQUAL(v.empty(), true);
369  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
370  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
371 }
372 
373 BOOST_AUTO_TEST_SUITE_END()
374 
375 BOOST_AUTO_TEST_SUITE(nonempty_colln)
376 
377 BOOST_AUTO_TEST_SUITE(one_element)
378 
379 BOOST_AUTO_TEST_CASE_TEMPLATE(transform, T, finite_test_types) {
380  typedef typename T::vtr_colln_t vtr_colln_t;
381  typedef typename T::pool_type pool_type;
382  typedef typename pool_type::joinable joinable;
383 
384  pool_type pool(T::pool_size);
385  vtr_colln_t v{1}, v_out;
386  auto const &context=pool<<joinable()<<pool.transform(v, v_out, std::negate<typename vtr_colln_t::value_type>());
387  pool.min_time(vtr_colln_t::memory_access_mode);
388  pool.min_processors(vtr_colln_t::memory_access_mode);
389  *context;
390  BOOST_CHECK_EQUAL(v.size(), 1U);
391  BOOST_CHECK_EQUAL(v_out.size(), 1U);
392  BOOST_CHECK_EQUAL(v_out[0], -v[0]);
393 }
394 
395 BOOST_AUTO_TEST_CASE_TEMPLATE(transform_2_collns, T, finite_test_types) {
396  typedef typename T::vtr_colln_t vtr_colln_t;
397  typedef typename T::pool_type pool_type;
398  typedef typename pool_type::joinable joinable;
399 
400  pool_type pool(T::pool_size);
401  vtr_colln_t v{1}, v1{1}, v_out;
402  auto const &context=pool<<joinable()<<pool.transform(v, v1, v_out, std::plus<typename vtr_colln_t::value_type>());
403  pool.min_time(vtr_colln_t::memory_access_mode);
404  pool.min_processors(vtr_colln_t::memory_access_mode);
405  *context;
406  BOOST_CHECK_EQUAL(v.size(), 1U);
407  BOOST_CHECK_EQUAL(v1.size(), 1U);
408  BOOST_CHECK_EQUAL(v_out.size(), 1U);
409  BOOST_CHECK_EQUAL(v_out[0], v[0]+v1[0]);
410 }
411 
412 BOOST_AUTO_TEST_CASE_TEMPLATE(copy, 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{1}, v_out;
419  auto const &context=pool<<joinable()<<pool.copy(v, v_out);
420  pool.min_time(vtr_colln_t::memory_access_mode);
421  pool.min_processors(vtr_colln_t::memory_access_mode);
422  *context;
423  BOOST_CHECK_EQUAL(v.size(), 1U);
424  BOOST_CHECK(v==v_out);
425 }
426 
427 BOOST_AUTO_TEST_CASE_TEMPLATE(fill_n, T, finite_test_types) {
428  typedef typename T::vtr_colln_t vtr_colln_t;
429  typedef typename T::pool_type pool_type;
430  typedef typename pool_type::joinable joinable;
431 
432  pool_type pool(T::pool_size);
433  vtr_colln_t v{1};
434  auto const &context=pool<<joinable()<<pool.fill_n(v, 2, typename vtr_colln_t::value_type(2));
435  *context;
436  BOOST_CHECK_EQUAL(v.empty(), false);
437  BOOST_CHECK_EQUAL(v.size(), 2);
438  BOOST_CHECK_EQUAL(v[0], 2);
439  BOOST_CHECK_EQUAL(v[1], 2);
440 }
441 
442 BOOST_AUTO_TEST_CASE_TEMPLATE(fill, T, finite_test_types) {
443  typedef typename T::vtr_colln_t vtr_colln_t;
444  typedef typename T::pool_type pool_type;
445  typedef typename pool_type::joinable joinable;
446 
447  pool_type pool(T::pool_size);
448  vtr_colln_t v{1};
449  auto const &context=pool<<joinable()<<pool.fill(v, typename vtr_colln_t::value_type(2));
450  *context;
451  BOOST_CHECK_EQUAL(v.empty(), false);
452  BOOST_CHECK_EQUAL(v.size(), 1);
453  BOOST_CHECK_EQUAL(v[0], 2);
454 }
455 
456 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse, 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{1};
463  auto const &context=pool<<joinable()<<pool.reverse(v);
464  *context;
465  BOOST_CHECK_EQUAL(v.empty(), false);
466  BOOST_CHECK_EQUAL(v.size(), 1);
467  BOOST_CHECK_EQUAL(v[0], 1);
468 }
469 
470 BOOST_AUTO_TEST_SUITE_END()
471 
472 BOOST_AUTO_TEST_SUITE(two_elements)
473 
474 BOOST_AUTO_TEST_CASE_TEMPLATE(transform, T, finite_test_types) {
475  typedef typename T::vtr_colln_t vtr_colln_t;
476  typedef typename T::pool_type pool_type;
477  typedef typename pool_type::joinable joinable;
478 
479  pool_type pool(T::pool_size);
480  vtr_colln_t v{1, 2}, v_out;
481  auto const &context=pool<<joinable()<<pool.transform(v, v_out, std::negate<typename vtr_colln_t::value_type>());
482  pool.min_time(vtr_colln_t::memory_access_mode);
483  pool.min_processors(vtr_colln_t::memory_access_mode);
484  *context;
485  BOOST_CHECK_EQUAL(v.size(), 2U);
486  BOOST_CHECK_EQUAL(v_out.size(), 2U);
487  BOOST_CHECK_EQUAL(v_out[0], -v[0]);
488  BOOST_CHECK_EQUAL(v_out[1], -v[1]);
489 }
490 
491 BOOST_AUTO_TEST_CASE_TEMPLATE(transform_2_collns, T, finite_test_types) {
492  typedef typename T::vtr_colln_t vtr_colln_t;
493  typedef typename T::pool_type pool_type;
494  typedef typename pool_type::joinable joinable;
495 
496  pool_type pool(T::pool_size);
497  vtr_colln_t v{1, 2}, v1{1, 2}, v_out;
498  auto const &context=pool<<joinable()<<pool.transform(v, v1, v_out, std::plus<typename vtr_colln_t::value_type>());
499  pool.min_time(vtr_colln_t::memory_access_mode);
500  pool.min_processors(vtr_colln_t::memory_access_mode);
501  *context;
502  BOOST_CHECK_EQUAL(v.size(), 2U);
503  BOOST_CHECK_EQUAL(v1.size(), 2U);
504  BOOST_CHECK_EQUAL(v_out.size(), 2U);
505  BOOST_CHECK_EQUAL(v_out[0], v[0]+v1[0]);
506  BOOST_CHECK_EQUAL(v_out[1], v[1]+v1[1]);
507 }
508 
509 BOOST_AUTO_TEST_CASE_TEMPLATE(copy, T, finite_test_types) {
510  typedef typename T::vtr_colln_t vtr_colln_t;
511  typedef typename T::pool_type pool_type;
512  typedef typename pool_type::joinable joinable;
513 
514  pool_type pool(T::pool_size);
515  vtr_colln_t v{1, 2}, v_out;
516  auto const &context=pool<<joinable()<<pool.copy(v, v_out);
517  pool.min_time(vtr_colln_t::memory_access_mode);
518  pool.min_processors(vtr_colln_t::memory_access_mode);
519  *context;
520  BOOST_CHECK_EQUAL(v.size(), 2U);
521  BOOST_CHECK(v==v_out);
522 }
523 
524 BOOST_AUTO_TEST_CASE_TEMPLATE(fill_n, T, finite_test_types) {
525  typedef typename T::vtr_colln_t vtr_colln_t;
526  typedef typename T::pool_type pool_type;
527  typedef typename pool_type::joinable joinable;
528 
529  pool_type pool(T::pool_size);
530  vtr_colln_t v{1, 2};
531  auto const &context=pool<<joinable()<<pool.fill_n(v, 2, typename vtr_colln_t::value_type(3));
532  *context;
533  BOOST_CHECK_EQUAL(v.empty(), false);
534  BOOST_CHECK_EQUAL(v.size(), 2);
535  BOOST_CHECK_EQUAL(v[0], 3);
536  BOOST_CHECK_EQUAL(v[1], 3);
537 }
538 
539 BOOST_AUTO_TEST_CASE_TEMPLATE(fill, T, finite_test_types) {
540  typedef typename T::vtr_colln_t vtr_colln_t;
541  typedef typename T::pool_type pool_type;
542  typedef typename pool_type::joinable joinable;
543 
544  pool_type pool(T::pool_size);
545  vtr_colln_t v{1, 2};
546  auto const &context=pool<<joinable()<<pool.fill(v, typename vtr_colln_t::value_type(3));
547  *context;
548  BOOST_CHECK_EQUAL(v.empty(), false);
549  BOOST_CHECK_EQUAL(v.size(), 2);
550  BOOST_CHECK_EQUAL(v[0], 3);
551  BOOST_CHECK_EQUAL(v[1], 3);
552 }
553 
554 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse, T, finite_test_types) {
555  typedef typename T::vtr_colln_t vtr_colln_t;
556  typedef typename T::pool_type pool_type;
557  typedef typename pool_type::joinable joinable;
558 
559  pool_type pool(T::pool_size);
560  vtr_colln_t v{1, 2};
561  auto const &context=pool<<joinable()<<pool.reverse(v);
562  *context;
563  BOOST_CHECK_EQUAL(v.empty(), false);
564  BOOST_CHECK_EQUAL(v.size(), 2);
565  BOOST_CHECK_EQUAL(v[0], 2);
566  BOOST_CHECK_EQUAL(v[1], 1);
567 }
568 
569 BOOST_AUTO_TEST_SUITE_END()
570 
571 BOOST_AUTO_TEST_SUITE(n_elements)
572 
573 BOOST_AUTO_TEST_CASE_TEMPLATE(transform, 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{1, 2, 3, 4, 5, 6, 7, 8}, v_out;
580  auto const &context=pool<<joinable()<<pool.transform(v, v_out, std::negate<typename vtr_colln_t::value_type>());
581  pool.min_time(vtr_colln_t::memory_access_mode);
582  pool.min_processors(vtr_colln_t::memory_access_mode);
583  *context;
584  BOOST_CHECK_EQUAL(v.size(), 8U);
585  BOOST_CHECK_EQUAL(v_out.size(), 8U);
586  BOOST_CHECK_EQUAL(v_out[0], -v[0]);
587  BOOST_CHECK_EQUAL(v_out[1], -v[1]);
588  BOOST_CHECK_EQUAL(v_out[2], -v[2]);
589  BOOST_CHECK_EQUAL(v_out[3], -v[3]);
590  BOOST_CHECK_EQUAL(v_out[4], -v[4]);
591  BOOST_CHECK_EQUAL(v_out[5], -v[5]);
592  BOOST_CHECK_EQUAL(v_out[6], -v[6]);
593  BOOST_CHECK_EQUAL(v_out[7], -v[7]);
594 }
595 
596 BOOST_AUTO_TEST_CASE_TEMPLATE(transform_2_collns, T, finite_test_types) {
597  typedef typename T::vtr_colln_t vtr_colln_t;
598  typedef typename T::pool_type pool_type;
599  typedef typename pool_type::joinable joinable;
600 
601  pool_type pool(T::pool_size);
602  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8}, v1{1, 2, 3, 4, 5, 6, 7, 8}, v_out;
603  auto const &context=pool<<joinable()<<pool.transform(v, v1, v_out, std::plus<typename vtr_colln_t::value_type>());
604  pool.min_time(vtr_colln_t::memory_access_mode);
605  pool.min_processors(vtr_colln_t::memory_access_mode);
606  *context;
607  BOOST_CHECK_EQUAL(v.size(), 8U);
608  BOOST_CHECK_EQUAL(v1.size(), 8U);
609  BOOST_CHECK_EQUAL(v_out.size(), 8U);
610  BOOST_CHECK_EQUAL(v_out[0], v[0]+v1[0]);
611  BOOST_CHECK_EQUAL(v_out[1], v[1]+v1[1]);
612  BOOST_CHECK_EQUAL(v_out[2], v[2]+v1[2]);
613  BOOST_CHECK_EQUAL(v_out[3], v[3]+v1[3]);
614  BOOST_CHECK_EQUAL(v_out[4], v[4]+v1[4]);
615  BOOST_CHECK_EQUAL(v_out[5], v[5]+v1[5]);
616  BOOST_CHECK_EQUAL(v_out[6], v[6]+v1[6]);
617  BOOST_CHECK_EQUAL(v_out[7], v[7]+v1[7]);
618 }
619 
620 BOOST_AUTO_TEST_CASE_TEMPLATE(copy, T, finite_test_types) {
621  typedef typename T::vtr_colln_t vtr_colln_t;
622  typedef typename T::pool_type pool_type;
623  typedef typename pool_type::joinable joinable;
624 
625  pool_type pool(T::pool_size);
626  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8}, v_out;
627  auto const &context=pool<<joinable()<<pool.copy(v, v_out);
628  pool.min_time(vtr_colln_t::memory_access_mode);
629  pool.min_processors(vtr_colln_t::memory_access_mode);
630  *context;
631  BOOST_CHECK_EQUAL(v.size(), 8U);
632  BOOST_CHECK(v==v_out);
633 }
634 
635 BOOST_AUTO_TEST_CASE_TEMPLATE(two_sequential_independent_copies, T, finite_test_types) {
636  typedef typename T::vtr_colln_t vtr_colln_t;
637  typedef typename T::pool_type pool_type;
638  typedef typename pool_type::joinable joinable;
639 
640  pool_type pool(T::pool_size);
641  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8}, v1{11, 22, 33, 44, 55, 66, 77, 88}, v3, v4;
642  v3.reserve(v.size()+v1.size());
643  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
644  *context1;
645  auto const &context2=pool<<joinable()<<pool.copy(v1,v4);
646  *context2;
647  BOOST_CHECK_EQUAL(v3.size(), 8U);
648  BOOST_CHECK(v==v3);
649  BOOST_CHECK_EQUAL(v4.size(), 8U);
650  BOOST_CHECK(v1==v4);
651  vtr_colln_t v_chk;
652  v_chk.reserve(v3.size()*2);
653  std::copy(v3.colln().begin(), v3.colln().end(), std::back_inserter(v_chk.colln()));
654  BOOST_CHECK_EQUAL(v_chk.colln().size(), 8U);
655  BOOST_CHECK_EQUAL(v_chk.size(), 8U);
656  BOOST_CHECK(v==v_chk);
657 }
658 
659 BOOST_AUTO_TEST_CASE_TEMPLATE(two_concurrent_independent_copies, T, finite_test_types) {
660  typedef typename T::vtr_colln_t vtr_colln_t;
661  typedef typename T::pool_type pool_type;
662  typedef typename pool_type::joinable joinable;
663 
664  pool_type pool(T::pool_size);
665  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8}, v1{11, 22, 33, 44, 55, 66, 77, 88}, v3, v4;
666  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
667  auto const &context2=pool<<joinable()<<pool.copy(v1, v4);
668  *context1;
669  *context2;
670  BOOST_CHECK_EQUAL(v3.size(), 8U);
671  BOOST_CHECK(v==v3);
672  BOOST_CHECK_EQUAL(v4.size(), 8U);
673  BOOST_CHECK(v1==v4);
674 }
675 
676 BOOST_AUTO_TEST_CASE_TEMPLATE(two_concurrent_dependent_copies_second_larger, T, finite_test_types) {
677  typedef typename T::vtr_colln_t vtr_colln_t;
678  typedef typename T::pool_type pool_type;
679  typedef typename pool_type::joinable joinable;
680 
681  pool_type pool(T::pool_size);
682  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8}, v1{11, 22, 33, 44, 55, 66, 77, 88, 99}, v3;
683  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
684  auto const &context2=pool<<joinable()<<pool.copy(v1, v3);
685  *context1;
686  *context2;
687  BOOST_CHECK_EQUAL(v.size(), 8U);
688  BOOST_CHECK_EQUAL(v1.size(), 9U);
689  BOOST_CHECK(v3.size()==v1.size());
690  BOOST_CHECK(v3==v1);
691 }
692 
693 BOOST_AUTO_TEST_CASE_TEMPLATE(two_concurrent_dependent_copies_invert_dependencies, T, finite_test_types) {
694  typedef typename T::vtr_colln_t vtr_colln_t;
695  typedef typename T::pool_type pool_type;
696  typedef typename pool_type::joinable joinable;
697 
698  pool_type pool(T::pool_size);
699  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8}, v1{11, 22, 33, 44, 55, 66, 77, 88, 99}, v3;
700  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
701  auto const &context2=pool<<joinable()<<pool.copy(v1, v3);
702  *context2;
703  *context1;
704  BOOST_CHECK_EQUAL(v.size(), 8U);
705  BOOST_CHECK_EQUAL(v1.size(), 9U);
706  BOOST_CHECK(v3.size()==v1.size());
707  BOOST_CHECK(v3==v1);
708 }
709 
710 BOOST_AUTO_TEST_CASE_TEMPLATE(two_concurrent_dependent_copies_second_smaller, T, finite_test_types) {
711  typedef typename T::vtr_colln_t vtr_colln_t;
712  typedef typename T::pool_type pool_type;
713  typedef typename pool_type::joinable joinable;
714 
715  pool_type pool(T::pool_size);
716  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8}, v1{11, 22, 33, 44, 55}, v3;
717  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
718  auto const &context2=pool<<joinable()<<pool.copy(v1, v3);
719  *context1;
720  *context2;
721  BOOST_CHECK_EQUAL(v.size(), 8U);
722  BOOST_CHECK_EQUAL(v1.size(), 5U);
723  BOOST_CHECK(v3.size()==v1.size());
724  BOOST_CHECK(v3[0]==v1[0]);
725  BOOST_CHECK(v3[1]==v1[1]);
726  BOOST_CHECK(v3[2]==v1[2]);
727  BOOST_CHECK(v3[3]==v1[3]);
728  BOOST_CHECK(v3[4]==v1[4]);
729  BOOST_CHECK(v3[5]==v[5]);
730  BOOST_CHECK(v3[6]==v[6]);
731  BOOST_CHECK(v3[7]==v[7]);
732 }
733 
734 BOOST_AUTO_TEST_CASE_TEMPLATE(fill_n, T, finite_test_types) {
735  typedef typename T::vtr_colln_t vtr_colln_t;
736  typedef typename T::pool_type pool_type;
737  typedef typename pool_type::joinable joinable;
738 
739  pool_type pool(T::pool_size);
740  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8};
741  auto const &context=pool<<joinable()<<pool.fill_n(v, 2, typename vtr_colln_t::value_type(9));
742  *context;
743  BOOST_CHECK_EQUAL(v.empty(), false);
744  BOOST_CHECK_EQUAL(v.size(), 2U);
745  BOOST_CHECK_EQUAL(v[0], 9);
746  BOOST_CHECK_EQUAL(v[1], 9);
747  BOOST_CHECK_EQUAL(v[2], 3);
748  BOOST_CHECK_EQUAL(v[3], 4);
749  BOOST_CHECK_EQUAL(v[4], 5);
750  BOOST_CHECK_EQUAL(v[5], 6);
751  BOOST_CHECK_EQUAL(v[6], 7);
752  BOOST_CHECK_EQUAL(v[7], 8);
753 }
754 
755 BOOST_AUTO_TEST_CASE_TEMPLATE(fill, T, finite_test_types) {
756  typedef typename T::vtr_colln_t vtr_colln_t;
757  typedef typename T::pool_type pool_type;
758  typedef typename pool_type::joinable joinable;
759 
760  pool_type pool(T::pool_size);
761  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8};
762  auto const &context=pool<<joinable()<<pool.fill(v, typename vtr_colln_t::value_type(9));
763  *context;
764  BOOST_CHECK_EQUAL(v.empty(), false);
765  BOOST_CHECK_EQUAL(v.size(), 8);
766  BOOST_CHECK_EQUAL(v[0], 9);
767  BOOST_CHECK_EQUAL(v[1], 9);
768  BOOST_CHECK_EQUAL(v[2], 9);
769  BOOST_CHECK_EQUAL(v[3], 9);
770  BOOST_CHECK_EQUAL(v[4], 9);
771  BOOST_CHECK_EQUAL(v[5], 9);
772  BOOST_CHECK_EQUAL(v[6], 9);
773  BOOST_CHECK_EQUAL(v[7], 9);
774 }
775 
776 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse_8_elems, 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{1, 2, 3, 4, 5, 6, 7, 8};
783  auto const &context=pool<<joinable()<<pool.reverse(v);
784  *context;
785  BOOST_CHECK_EQUAL(v.empty(), false);
786  BOOST_CHECK_EQUAL(v.size(), 8);
787  BOOST_CHECK_EQUAL(v[0], 8);
788  BOOST_CHECK_EQUAL(v[1], 7);
789  BOOST_CHECK_EQUAL(v[2], 6);
790  BOOST_CHECK_EQUAL(v[3], 5);
791  BOOST_CHECK_EQUAL(v[4], 4);
792  BOOST_CHECK_EQUAL(v[5], 3);
793  BOOST_CHECK_EQUAL(v[6], 2);
794  BOOST_CHECK_EQUAL(v[7], 1);
795 }
796 
797 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse_9_elems, T, finite_test_types) {
798  typedef typename T::vtr_colln_t vtr_colln_t;
799  typedef typename T::pool_type pool_type;
800  typedef typename pool_type::joinable joinable;
801 
802  pool_type pool(T::pool_size);
803  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8, 9};
804  auto const &context=pool<<joinable()<<pool.reverse(v);
805  *context;
806  BOOST_CHECK_EQUAL(v.empty(), false);
807  BOOST_CHECK_EQUAL(v.size(), 9);
808  BOOST_CHECK_EQUAL(v[0], 9);
809  BOOST_CHECK_EQUAL(v[1], 8);
810  BOOST_CHECK_EQUAL(v[2], 7);
811  BOOST_CHECK_EQUAL(v[3], 6);
812  BOOST_CHECK_EQUAL(v[4], 5);
813  BOOST_CHECK_EQUAL(v[5], 4);
814  BOOST_CHECK_EQUAL(v[6], 3);
815  BOOST_CHECK_EQUAL(v[7], 2);
816  BOOST_CHECK_EQUAL(v[8], 1);
817 }
818 
819 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse_9_elems_clear, T, finite_test_types) {
820  typedef typename T::vtr_colln_t vtr_colln_t;
821  typedef typename T::pool_type pool_type;
822  typedef typename pool_type::joinable joinable;
823 
824  pool_type pool(T::pool_size);
825  vtr_colln_t v{1, 2, 3, 4, 5, 6, 7, 8, 9};
826  auto const &context=pool<<joinable()<<pool.reverse(v);
827  v.clear();
828  *context;
829  BOOST_CHECK_EQUAL(v.empty(), true);
830  BOOST_CHECK_EQUAL(v.size(), 0);
831 }
832 
833 BOOST_AUTO_TEST_SUITE_END()
834 
835 BOOST_AUTO_TEST_SUITE_END()
836 
837 BOOST_AUTO_TEST_SUITE_END()
838 
839 BOOST_AUTO_TEST_SUITE(infinite)
840 
841 BOOST_AUTO_TEST_SUITE(empty_colln)
842 
843 BOOST_AUTO_TEST_CASE_TEMPLATE(transform, 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, v_out;
850  auto const &context=pool<<joinable()<<pool.transform(v, v_out, std::negate<typename vtr_colln_t::value_type>());
851  pool.min_time(vtr_colln_t::memory_access_mode);
852  pool.min_processors(vtr_colln_t::memory_access_mode);
853  *context;
854  BOOST_CHECK_EQUAL(v.empty(), true);
855  BOOST_CHECK(v==v_out);
856  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
857  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
858 }
859 
860 BOOST_AUTO_TEST_CASE_TEMPLATE(transform_2_collns, T, infinite_test_types) {
861  typedef typename T::vtr_colln_t vtr_colln_t;
862  typedef typename T::pool_type pool_type;
863  typedef typename pool_type::joinable joinable;
864 
865  pool_type pool;
866  vtr_colln_t v, v1, v_out;
867  auto const &context=pool<<joinable()<<pool.transform(v, v1, v_out, std::plus<typename vtr_colln_t::value_type>());
868  pool.min_time(vtr_colln_t::memory_access_mode);
869  pool.min_processors(vtr_colln_t::memory_access_mode);
870  *context;
871  BOOST_CHECK_EQUAL(v.empty(), true);
872  BOOST_CHECK_EQUAL(v1.empty(), true);
873  BOOST_CHECK(v==v_out);
874  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
875  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
876 }
877 
878 BOOST_AUTO_TEST_CASE_TEMPLATE(copy, T, infinite_test_types) {
879  typedef typename T::vtr_colln_t vtr_colln_t;
880  typedef typename T::pool_type pool_type;
881  typedef typename pool_type::joinable joinable;
882 
883  pool_type pool;
884  vtr_colln_t v, v_out;
885  auto const &context=pool<<joinable()<<pool.copy(v, v_out);
886  pool.min_time(vtr_colln_t::memory_access_mode);
887  pool.min_processors(vtr_colln_t::memory_access_mode);
888  *context;
889  BOOST_CHECK_EQUAL(v.empty(), true);
890  BOOST_CHECK_EQUAL(v.size(), 0U);
891  BOOST_CHECK(v==v_out);
892  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
893  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
894 }
895 
896 BOOST_AUTO_TEST_CASE_TEMPLATE(fill_n, T, infinite_test_types) {
897  typedef typename T::vtr_colln_t vtr_colln_t;
898  typedef typename T::pool_type pool_type;
899  typedef typename pool_type::joinable joinable;
900 
901  pool_type pool;
902  vtr_colln_t v;
903  auto const &context=pool<<joinable()<<pool.fill_n(v, 1, typename vtr_colln_t::value_type(1));
904  *context;
905  BOOST_CHECK_EQUAL(v.empty(), false);
906  BOOST_CHECK_EQUAL(v.size(), 1);
907  BOOST_CHECK_EQUAL(v[0], 1);
908  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
909  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
910 }
911 
912 BOOST_AUTO_TEST_CASE_TEMPLATE(fill, T, infinite_test_types) {
913  typedef typename T::vtr_colln_t vtr_colln_t;
914  typedef typename T::pool_type pool_type;
915  typedef typename pool_type::joinable joinable;
916 
917  pool_type pool;
918  vtr_colln_t v;
919  auto const &context=pool<<joinable()<<pool.fill(v, typename vtr_colln_t::value_type(1));
920  *context;
921  BOOST_CHECK_EQUAL(v.empty(), true);
922  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
923  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
924 }
925 
926 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse, T, infinite_test_types) {
927  typedef typename T::vtr_colln_t vtr_colln_t;
928  typedef typename T::pool_type pool_type;
929  typedef typename pool_type::joinable joinable;
930 
931  pool_type pool;
932  vtr_colln_t v;
933  auto const &context=pool<<joinable()<<pool.reverse(v);
934  *context;
935  BOOST_CHECK_EQUAL(v.empty(), true);
936  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
937  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
938 }
939 
940 BOOST_AUTO_TEST_SUITE_END()
941 
942 BOOST_AUTO_TEST_SUITE_END()
943 
944 BOOST_AUTO_TEST_SUITE(nonempty_colln)
945 
946 BOOST_AUTO_TEST_SUITE(one_element)
947 
948 BOOST_AUTO_TEST_CASE_TEMPLATE(transform, T, infinite_test_types) {
949  typedef typename T::vtr_colln_t vtr_colln_t;
950  typedef typename T::pool_type pool_type;
951  typedef typename pool_type::joinable joinable;
952 
953  pool_type pool;
954  vtr_colln_t v, v_out;
955  v.push_back(1);
956  auto const &context=pool<<joinable()<<pool.transform(v, v_out, std::negate<typename vtr_colln_t::value_type>());
957  pool.min_time(vtr_colln_t::memory_access_mode);
958  pool.min_processors(vtr_colln_t::memory_access_mode);
959  *context;
960  BOOST_CHECK_EQUAL(v.size(), 1U);
961  BOOST_CHECK_EQUAL(v_out.size(), 1U);
962  BOOST_CHECK_EQUAL(v_out[0], -v[0]);
963 }
964 
965 BOOST_AUTO_TEST_CASE_TEMPLATE(transform_2_collns, T, infinite_test_types) {
966  typedef typename T::vtr_colln_t vtr_colln_t;
967  typedef typename T::pool_type pool_type;
968  typedef typename pool_type::joinable joinable;
969 
970  pool_type pool;
971  vtr_colln_t v, v1, v_out;
972  v.push_back(1);
973  v1.push_back(1);
974  auto const &context=pool<<joinable()<<pool.transform(v, v1, v_out, std::plus<typename vtr_colln_t::value_type>());
975  pool.min_time(vtr_colln_t::memory_access_mode);
976  pool.min_processors(vtr_colln_t::memory_access_mode);
977  *context;
978  BOOST_CHECK_EQUAL(v.size(), 1U);
979  BOOST_CHECK_EQUAL(v1.size(), 1U);
980  BOOST_CHECK_EQUAL(v_out.size(), 1U);
981  BOOST_CHECK_EQUAL(v_out[0], v[0]+v1[0]);
982 }
983 
984 BOOST_AUTO_TEST_CASE_TEMPLATE(copy, T, infinite_test_types) {
985  typedef typename T::vtr_colln_t vtr_colln_t;
986  typedef typename T::pool_type pool_type;
987  typedef typename pool_type::joinable joinable;
988 
989  pool_type pool;
990  vtr_colln_t v, v_out;
991  v.push_back(1);
992  auto const &context=pool<<joinable()<<pool.copy(v, v_out);
993  pool.min_time(vtr_colln_t::memory_access_mode);
994  pool.min_processors(vtr_colln_t::memory_access_mode);
995  *context;
996  BOOST_CHECK_EQUAL(v.size(), 1U);
997  BOOST_CHECK(v==v_out);
998 }
999 
1000 BOOST_AUTO_TEST_CASE_TEMPLATE(fill_n, T, infinite_test_types) {
1001  typedef typename T::vtr_colln_t vtr_colln_t;
1002  typedef typename T::pool_type pool_type;
1003  typedef typename pool_type::joinable joinable;
1004 
1005  pool_type pool;
1006  vtr_colln_t v;
1007  v.push_back(1);
1008  auto const &context=pool<<joinable()<<pool.fill_n(v, 2, typename vtr_colln_t::value_type(2));
1009  *context;
1010  BOOST_CHECK_EQUAL(v.empty(), false);
1011  BOOST_CHECK_EQUAL(v.size(), 2);
1012  BOOST_CHECK_EQUAL(v[0], 2);
1013  BOOST_CHECK_EQUAL(v[1], 2);
1014 }
1015 
1016 BOOST_AUTO_TEST_CASE_TEMPLATE(fill, T, infinite_test_types) {
1017  typedef typename T::vtr_colln_t vtr_colln_t;
1018  typedef typename T::pool_type pool_type;
1019  typedef typename pool_type::joinable joinable;
1020 
1021  pool_type pool;
1022  vtr_colln_t v;
1023  v.push_back(1);
1024  auto const &context=pool<<joinable()<<pool.fill(v, typename vtr_colln_t::value_type(2));
1025  *context;
1026  BOOST_CHECK_EQUAL(v.empty(), false);
1027  BOOST_CHECK_EQUAL(v.size(), 1);
1028  BOOST_CHECK_EQUAL(v[0], 2);
1029 }
1030 
1031 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse, T, infinite_test_types) {
1032  typedef typename T::vtr_colln_t vtr_colln_t;
1033  typedef typename T::pool_type pool_type;
1034  typedef typename pool_type::joinable joinable;
1035 
1036  pool_type pool;
1037  vtr_colln_t v;
1038  v.push_back(1);
1039  auto const &context=pool<<joinable()<<pool.reverse(v);
1040  *context;
1041  BOOST_CHECK_EQUAL(v.empty(), false);
1042  BOOST_CHECK_EQUAL(v.size(), 1);
1043  BOOST_CHECK_EQUAL(v[0], 1);
1044 }
1045 
1046 BOOST_AUTO_TEST_SUITE_END()
1047 
1048 BOOST_AUTO_TEST_SUITE(two_elements)
1049 
1050 BOOST_AUTO_TEST_CASE_TEMPLATE(transform, T, infinite_test_types) {
1051  typedef typename T::vtr_colln_t vtr_colln_t;
1052  typedef typename T::pool_type pool_type;
1053  typedef typename pool_type::joinable joinable;
1054 
1055  pool_type pool;
1056  vtr_colln_t v, v_out;
1057  v.push_back(1);
1058  v.push_back(2);
1059  auto const &context=pool<<joinable()<<pool.transform(v, v_out, std::negate<typename vtr_colln_t::value_type>());
1060  pool.min_time(vtr_colln_t::memory_access_mode);
1061  pool.min_processors(vtr_colln_t::memory_access_mode);
1062  *context;
1063  BOOST_CHECK_EQUAL(v.size(), 2U);
1064  BOOST_CHECK_EQUAL(v_out.size(), 2U);
1065  BOOST_CHECK_EQUAL(v_out[0], -v[0]);
1066  BOOST_CHECK_EQUAL(v_out[1], -v[1]);
1067 }
1068 
1069 BOOST_AUTO_TEST_CASE_TEMPLATE(transform_2_collns, T, infinite_test_types) {
1070  typedef typename T::vtr_colln_t vtr_colln_t;
1071  typedef typename T::pool_type pool_type;
1072  typedef typename pool_type::joinable joinable;
1073 
1074  pool_type pool;
1075  vtr_colln_t v, v1, v_out;
1076  v.push_back(1);
1077  v.push_back(2);
1078  v1.push_back(1);
1079  v1.push_back(2);
1080  auto const &context=pool<<joinable()<<pool.transform(v, v1, v_out, std::plus<typename vtr_colln_t::value_type>());
1081  pool.min_time(vtr_colln_t::memory_access_mode);
1082  pool.min_processors(vtr_colln_t::memory_access_mode);
1083  *context;
1084  BOOST_CHECK_EQUAL(v.size(), 2U);
1085  BOOST_CHECK_EQUAL(v1.size(), 2U);
1086  BOOST_CHECK_EQUAL(v_out.size(), 2U);
1087  BOOST_CHECK_EQUAL(v_out[0], v[0]+v1[0]);
1088  BOOST_CHECK_EQUAL(v_out[1], v[1]+v1[1]);
1089 }
1090 
1091 BOOST_AUTO_TEST_CASE_TEMPLATE(copy, T, infinite_test_types) {
1092  typedef typename T::vtr_colln_t vtr_colln_t;
1093  typedef typename T::pool_type pool_type;
1094  typedef typename pool_type::joinable joinable;
1095 
1096  pool_type pool;
1097  vtr_colln_t v, v_out;
1098  v.push_back(1);
1099  v.push_back(2);
1100  auto const &context=pool<<joinable()<<pool.copy(v, v_out);
1101  pool.min_time(vtr_colln_t::memory_access_mode);
1102  pool.min_processors(vtr_colln_t::memory_access_mode);
1103  *context;
1104  BOOST_CHECK_EQUAL(v.size(), 2U);
1105  BOOST_CHECK(v==v_out);
1106 }
1107 
1108 BOOST_AUTO_TEST_CASE_TEMPLATE(fill_n, T, infinite_test_types) {
1109  typedef typename T::vtr_colln_t vtr_colln_t;
1110  typedef typename T::pool_type pool_type;
1111  typedef typename pool_type::joinable joinable;
1112 
1113  pool_type pool;
1114  vtr_colln_t v;
1115  v.push_back(1);
1116  v.push_back(2);
1117  auto const &context=pool<<joinable()<<pool.fill_n(v, 2, typename vtr_colln_t::value_type(3));
1118  *context;
1119  BOOST_CHECK_EQUAL(v.empty(), false);
1120  BOOST_CHECK_EQUAL(v.size(), 2);
1121  BOOST_CHECK_EQUAL(v[0], 3);
1122  BOOST_CHECK_EQUAL(v[1], 3);
1123 }
1124 
1125 BOOST_AUTO_TEST_CASE_TEMPLATE(fill, T, infinite_test_types) {
1126  typedef typename T::vtr_colln_t vtr_colln_t;
1127  typedef typename T::pool_type pool_type;
1128  typedef typename pool_type::joinable joinable;
1129 
1130  pool_type pool;
1131  vtr_colln_t v;
1132  v.push_back(1);
1133  v.push_back(2);
1134  auto const &context=pool<<joinable()<<pool.fill(v, typename vtr_colln_t::value_type(3));
1135  *context;
1136  BOOST_CHECK_EQUAL(v.empty(), false);
1137  BOOST_CHECK_EQUAL(v.size(), 2);
1138  BOOST_CHECK_EQUAL(v[0], 3);
1139  BOOST_CHECK_EQUAL(v[1], 3);
1140 }
1141 
1142 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse, T, infinite_test_types) {
1143  typedef typename T::vtr_colln_t vtr_colln_t;
1144  typedef typename T::pool_type pool_type;
1145  typedef typename pool_type::joinable joinable;
1146 
1147  pool_type pool;
1148  vtr_colln_t v;
1149  v.push_back(1);
1150  v.push_back(2);
1151  auto const &context=pool<<joinable()<<pool.reverse(v);
1152  *context;
1153  BOOST_CHECK_EQUAL(v.empty(), false);
1154  BOOST_CHECK_EQUAL(v.size(), 2);
1155  BOOST_CHECK_EQUAL(v[0], 2);
1156  BOOST_CHECK_EQUAL(v[1], 1);
1157 }
1158 
1159 BOOST_AUTO_TEST_SUITE_END()
1160 
1161 BOOST_AUTO_TEST_SUITE(n_elements)
1162 
1163 BOOST_AUTO_TEST_CASE_TEMPLATE(transform, T, infinite_test_types) {
1164  typedef typename T::vtr_colln_t vtr_colln_t;
1165  typedef typename T::pool_type pool_type;
1166  typedef typename pool_type::joinable joinable;
1167 
1168  pool_type pool;
1169  vtr_colln_t v, v_out;
1170  v.push_back(1);
1171  v.push_back(2);
1172  v.push_back(3);
1173  v.push_back(4);
1174  v.push_back(5);
1175  v.push_back(6);
1176  v.push_back(7);
1177  v.push_back(8);
1178  auto const &context=pool<<joinable()<<pool.transform(v, v_out, std::negate<typename vtr_colln_t::value_type>());
1179  pool.min_time(vtr_colln_t::memory_access_mode);
1180  pool.min_processors(vtr_colln_t::memory_access_mode);
1181  *context;
1182  BOOST_CHECK_EQUAL(v.size(), 8U);
1183  BOOST_CHECK_EQUAL(v_out.size(), 8U);
1184  BOOST_CHECK_EQUAL(v_out[0], -v[0]);
1185  BOOST_CHECK_EQUAL(v_out[1], -v[1]);
1186  BOOST_CHECK_EQUAL(v_out[2], -v[2]);
1187  BOOST_CHECK_EQUAL(v_out[3], -v[3]);
1188  BOOST_CHECK_EQUAL(v_out[4], -v[4]);
1189  BOOST_CHECK_EQUAL(v_out[5], -v[5]);
1190  BOOST_CHECK_EQUAL(v_out[6], -v[6]);
1191  BOOST_CHECK_EQUAL(v_out[7], -v[7]);
1192 }
1193 
1194 BOOST_AUTO_TEST_CASE_TEMPLATE(transform_2_collns, T, infinite_test_types) {
1195  typedef typename T::vtr_colln_t vtr_colln_t;
1196  typedef typename T::pool_type pool_type;
1197  typedef typename pool_type::joinable joinable;
1198 
1199  pool_type pool;
1200  vtr_colln_t v, v1, v_out;
1201  v.push_back(1);
1202  v.push_back(2);
1203  v.push_back(3);
1204  v.push_back(4);
1205  v.push_back(5);
1206  v.push_back(6);
1207  v.push_back(7);
1208  v.push_back(8);
1209  v1.push_back(1);
1210  v1.push_back(2);
1211  v1.push_back(3);
1212  v1.push_back(4);
1213  v1.push_back(5);
1214  v1.push_back(6);
1215  v1.push_back(7);
1216  v1.push_back(8);
1217  auto const &context=pool<<joinable()<<pool.transform(v, v1, v_out, std::plus<typename vtr_colln_t::value_type>());
1218  pool.min_time(vtr_colln_t::memory_access_mode);
1219  pool.min_processors(vtr_colln_t::memory_access_mode);
1220  *context;
1221  BOOST_CHECK_EQUAL(v.size(), 8U);
1222  BOOST_CHECK_EQUAL(v1.size(), 8U);
1223  BOOST_CHECK_EQUAL(v_out.size(), 8U);
1224  BOOST_CHECK_EQUAL(v_out[0], v[0]+v1[0]);
1225  BOOST_CHECK_EQUAL(v_out[1], v[1]+v1[1]);
1226  BOOST_CHECK_EQUAL(v_out[2], v[2]+v1[2]);
1227  BOOST_CHECK_EQUAL(v_out[3], v[3]+v1[3]);
1228  BOOST_CHECK_EQUAL(v_out[4], v[4]+v1[4]);
1229  BOOST_CHECK_EQUAL(v_out[5], v[5]+v1[5]);
1230  BOOST_CHECK_EQUAL(v_out[6], v[6]+v1[6]);
1231  BOOST_CHECK_EQUAL(v_out[7], v[7]+v1[7]);
1232 }
1233 
1234 BOOST_AUTO_TEST_CASE_TEMPLATE(copy, T, infinite_test_types) {
1235  typedef typename T::vtr_colln_t vtr_colln_t;
1236  typedef typename T::pool_type pool_type;
1237  typedef typename pool_type::joinable joinable;
1238 
1239  pool_type pool;
1240  vtr_colln_t v, v_out;
1241  v.push_back(1);
1242  v.push_back(2);
1243  v.push_back(3);
1244  v.push_back(4);
1245  v.push_back(5);
1246  v.push_back(6);
1247  v.push_back(7);
1248  v.push_back(8);
1249  auto const &context=pool<<joinable()<<pool.copy(v, v_out);
1250  pool.min_time(vtr_colln_t::memory_access_mode);
1251  pool.min_processors(vtr_colln_t::memory_access_mode);
1252  *context;
1253  BOOST_CHECK_EQUAL(v.size(), 8U);
1254  BOOST_CHECK(v==v_out);
1255 }
1256 
1257 BOOST_AUTO_TEST_CASE_TEMPLATE(two_sequential_independent_copies, T, infinite_test_types) {
1258  typedef typename T::vtr_colln_t vtr_colln_t;
1259  typedef typename T::pool_type pool_type;
1260  typedef typename pool_type::joinable joinable;
1261 
1262  pool_type pool;
1263  vtr_colln_t v, v1, v3, v4;
1264  v.push_back(1);
1265  v.push_back(2);
1266  v.push_back(3);
1267  v.push_back(4);
1268  v.push_back(5);
1269  v.push_back(6);
1270  v.push_back(7);
1271  v.push_back(8);
1272  v1.push_back(11);
1273  v1.push_back(22);
1274  v1.push_back(33);
1275  v1.push_back(44);
1276  v1.push_back(55);
1277  v1.push_back(66);
1278  v1.push_back(77);
1279  v1.push_back(88);
1280  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
1281  *context1;
1282  auto const &context2=pool<<joinable()<<pool.copy(v1, v4);
1283  *context2;
1284  BOOST_CHECK_EQUAL(v3.size(), 8U);
1285  BOOST_CHECK(v==v3);
1286  BOOST_CHECK_EQUAL(v4.size(), 8U);
1287  BOOST_CHECK(v1==v4);
1288 }
1289 
1290 BOOST_AUTO_TEST_CASE_TEMPLATE(two_concurrent_independent_copies, T, infinite_test_types) {
1291  typedef typename T::vtr_colln_t vtr_colln_t;
1292  typedef typename T::pool_type pool_type;
1293  typedef typename pool_type::joinable joinable;
1294 
1295  pool_type pool;
1296  vtr_colln_t v, v1, v3, v4;
1297  v.push_back(1);
1298  v.push_back(2);
1299  v.push_back(3);
1300  v.push_back(4);
1301  v.push_back(5);
1302  v.push_back(6);
1303  v.push_back(7);
1304  v.push_back(8);
1305  v1.push_back(11);
1306  v1.push_back(22);
1307  v1.push_back(33);
1308  v1.push_back(44);
1309  v1.push_back(55);
1310  v1.push_back(66);
1311  v1.push_back(77);
1312  v1.push_back(88);
1313  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
1314  auto const &context2=pool<<joinable()<<pool.copy(v1, v4);
1315  *context1;
1316  *context2;
1317  BOOST_CHECK_EQUAL(v3.size(), 8U);
1318  BOOST_CHECK(v==v3);
1319  BOOST_CHECK_EQUAL(v4.size(), 8U);
1320  BOOST_CHECK(v1==v4);
1321 }
1322 
1323 BOOST_AUTO_TEST_CASE_TEMPLATE(two_concurrent_dependent_copies_second_larger, T, infinite_test_types) {
1324  typedef typename T::vtr_colln_t vtr_colln_t;
1325  typedef typename T::pool_type pool_type;
1326  typedef typename pool_type::joinable joinable;
1327 
1328  pool_type pool;
1329  vtr_colln_t v, v1, v3;
1330  v.push_back(1);
1331  v.push_back(2);
1332  v.push_back(3);
1333  v.push_back(4);
1334  v.push_back(5);
1335  v.push_back(6);
1336  v.push_back(7);
1337  v.push_back(8);
1338  v1.push_back(11);
1339  v1.push_back(22);
1340  v1.push_back(33);
1341  v1.push_back(44);
1342  v1.push_back(55);
1343  v1.push_back(66);
1344  v1.push_back(77);
1345  v1.push_back(88);
1346  v1.push_back(99);
1347  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
1348  auto const &context2=pool<<joinable()<<pool.copy(v1, v3);
1349  *context1;
1350  *context2;
1351  BOOST_CHECK_EQUAL(v.size(), 8U);
1352  BOOST_CHECK_EQUAL(v1.size(), 9U);
1353  BOOST_CHECK(v3.size()==v1.size());
1354  BOOST_CHECK(v3==v1);
1355 }
1356 
1357 BOOST_AUTO_TEST_CASE_TEMPLATE(two_concurrent_dependent_copies_invert_dependencies, T, infinite_test_types) {
1358  typedef typename T::vtr_colln_t vtr_colln_t;
1359  typedef typename T::pool_type pool_type;
1360  typedef typename pool_type::joinable joinable;
1361 
1362  pool_type pool;
1363  vtr_colln_t v, v1, v3;
1364  v.push_back(1);
1365  v.push_back(2);
1366  v.push_back(3);
1367  v.push_back(4);
1368  v.push_back(5);
1369  v.push_back(6);
1370  v.push_back(7);
1371  v.push_back(8);
1372  v1.push_back(11);
1373  v1.push_back(22);
1374  v1.push_back(33);
1375  v1.push_back(44);
1376  v1.push_back(55);
1377  v1.push_back(66);
1378  v1.push_back(77);
1379  v1.push_back(88);
1380  v1.push_back(99);
1381  auto const &context1=pool<<joinable()<<pool.copy(v,v3);
1382  auto const &context2=pool<<joinable()<<pool.copy(v1,v3);
1383  *context2;
1384  *context1;
1385  BOOST_CHECK_EQUAL(v.size(), 8U);
1386  BOOST_CHECK_EQUAL(v1.size(), 9U);
1387  BOOST_CHECK(v3.size()==v1.size());
1388  BOOST_CHECK(v3==v1);
1389 }
1390 
1391 BOOST_AUTO_TEST_CASE_TEMPLATE(two_concurrent_dependent_copies_second_smaller, T, infinite_test_types) {
1392  typedef typename T::vtr_colln_t vtr_colln_t;
1393  typedef typename T::pool_type pool_type;
1394  typedef typename pool_type::joinable joinable;
1395 
1396  pool_type pool;
1397  vtr_colln_t v, v1, v3;
1398  v.push_back(1);
1399  v.push_back(2);
1400  v.push_back(3);
1401  v.push_back(4);
1402  v.push_back(5);
1403  v.push_back(6);
1404  v.push_back(7);
1405  v.push_back(8);
1406  v1.push_back(11);
1407  v1.push_back(22);
1408  v1.push_back(33);
1409  v1.push_back(44);
1410  v1.push_back(55);
1411  auto const &context1=pool<<joinable()<<pool.copy(v, v3);
1412  auto const &context2=pool<<joinable()<<pool.copy(v1, v3);
1413  *context1;
1414  *context2;
1415  BOOST_CHECK_EQUAL(v.size(), 8U);
1416  BOOST_CHECK_EQUAL(v1.size(), 5U);
1417  BOOST_CHECK(v3.size()==v1.size());
1418  BOOST_CHECK(v3==v1);
1419 }
1420 
1421 BOOST_AUTO_TEST_CASE_TEMPLATE(fill_n, T, infinite_test_types) {
1422  typedef typename T::vtr_colln_t vtr_colln_t;
1423  typedef typename T::pool_type pool_type;
1424  typedef typename pool_type::joinable joinable;
1425 
1426  pool_type pool;
1427  vtr_colln_t v;
1428  v.push_back(1);
1429  v.push_back(2);
1430  v.push_back(3);
1431  v.push_back(4);
1432  v.push_back(5);
1433  v.push_back(6);
1434  v.push_back(7);
1435  v.push_back(8);
1436  auto const &context=pool<<joinable()<<pool.fill_n(v, 2, typename vtr_colln_t::value_type(9));
1437  *context;
1438  BOOST_CHECK_EQUAL(v.empty(), false);
1439  BOOST_CHECK_EQUAL(v.size(), 2);
1440  BOOST_CHECK_EQUAL(v[0], 9);
1441  BOOST_CHECK_EQUAL(v[1], 9);
1442 }
1443 
1444 BOOST_AUTO_TEST_CASE_TEMPLATE(fill, T, infinite_test_types) {
1445  typedef typename T::vtr_colln_t vtr_colln_t;
1446  typedef typename T::pool_type pool_type;
1447  typedef typename pool_type::joinable joinable;
1448 
1449  pool_type pool;
1450  vtr_colln_t v;
1451  v.push_back(1);
1452  v.push_back(2);
1453  v.push_back(3);
1454  v.push_back(4);
1455  v.push_back(5);
1456  v.push_back(6);
1457  v.push_back(7);
1458  v.push_back(8);
1459  auto const &context=pool<<joinable()<<pool.fill(v, typename vtr_colln_t::value_type(9));
1460  *context;
1461  BOOST_CHECK_EQUAL(v.empty(), false);
1462  BOOST_CHECK_EQUAL(v.size(), 8);
1463  BOOST_CHECK_EQUAL(v[0], 9);
1464  BOOST_CHECK_EQUAL(v[1], 9);
1465  BOOST_CHECK_EQUAL(v[2], 9);
1466  BOOST_CHECK_EQUAL(v[3], 9);
1467  BOOST_CHECK_EQUAL(v[4], 9);
1468  BOOST_CHECK_EQUAL(v[5], 9);
1469  BOOST_CHECK_EQUAL(v[6], 9);
1470  BOOST_CHECK_EQUAL(v[7], 9);
1471 }
1472 
1473 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse_8_elems, T, infinite_test_types) {
1474  typedef typename T::vtr_colln_t vtr_colln_t;
1475  typedef typename T::pool_type pool_type;
1476  typedef typename pool_type::joinable joinable;
1477 
1478  pool_type pool;
1479  vtr_colln_t v;
1480  v.push_back(1);
1481  v.push_back(2);
1482  v.push_back(3);
1483  v.push_back(4);
1484  v.push_back(5);
1485  v.push_back(6);
1486  v.push_back(7);
1487  v.push_back(8);
1488  auto const &context=pool<<joinable()<<pool.reverse(v);
1489  *context;
1490  BOOST_CHECK_EQUAL(v.empty(), false);
1491  BOOST_CHECK_EQUAL(v.size(), 8);
1492  BOOST_CHECK_EQUAL(v[0], 8);
1493  BOOST_CHECK_EQUAL(v[1], 7);
1494  BOOST_CHECK_EQUAL(v[2], 6);
1495  BOOST_CHECK_EQUAL(v[3], 5);
1496  BOOST_CHECK_EQUAL(v[4], 4);
1497  BOOST_CHECK_EQUAL(v[5], 3);
1498  BOOST_CHECK_EQUAL(v[6], 2);
1499  BOOST_CHECK_EQUAL(v[7], 1);
1500 }
1501 
1502 BOOST_AUTO_TEST_CASE_TEMPLATE(reverse_9_elems, T, infinite_test_types) {
1503  typedef typename T::vtr_colln_t vtr_colln_t;
1504  typedef typename T::pool_type pool_type;
1505  typedef typename pool_type::joinable joinable;
1506 
1507  pool_type pool;
1508  vtr_colln_t v;
1509  v.push_back(1);
1510  v.push_back(2);
1511  v.push_back(3);
1512  v.push_back(4);
1513  v.push_back(5);
1514  v.push_back(6);
1515  v.push_back(7);
1516  v.push_back(8);
1517  v.push_back(9);
1518  auto const &context=pool<<joinable()<<pool.reverse(v);
1519  *context;
1520  BOOST_CHECK_EQUAL(v.empty(), false);
1521  BOOST_CHECK_EQUAL(v.size(), 9);
1522  BOOST_CHECK_EQUAL(v[0], 9);
1523  BOOST_CHECK_EQUAL(v[1], 8);
1524  BOOST_CHECK_EQUAL(v[2], 7);
1525  BOOST_CHECK_EQUAL(v[3], 6);
1526  BOOST_CHECK_EQUAL(v[4], 5);
1527  BOOST_CHECK_EQUAL(v[5], 4);
1528  BOOST_CHECK_EQUAL(v[6], 3);
1529  BOOST_CHECK_EQUAL(v[7], 2);
1530  BOOST_CHECK_EQUAL(v[8], 1);
1531 }
1532 
1533 BOOST_AUTO_TEST_SUITE_END()
1534 
1535 BOOST_AUTO_TEST_SUITE_END()
1536 
1537 BOOST_AUTO_TEST_SUITE_END()
1538 
1539 BOOST_AUTO_TEST_SUITE_END()