libjmmcg  release_579_6_g8cffd
A C++ library containing an eclectic mix of useful, advanced components.
dataflow_full_non-mod_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(for_each, 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;
283  square<typename vtr_colln_t::value_type>::last=0;
284  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
285  pool.min_time(vtr_colln_t::memory_access_mode);
286  pool.min_processors(vtr_colln_t::memory_access_mode);
287  *context;
288  BOOST_CHECK_EQUAL(v.empty(), true);
289  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 0);
290  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
291  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
292 }
293 
294 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each_cliques_1, T, finite_test_types) {
295  typedef typename T::vtr_colln_t vtr_colln_t;
296  typedef typename T::pool_type pool_type;
297  typedef typename pool_type::joinable joinable;
298 
299  pool_type pool(T::pool_size);
300  vtr_colln_t v;
301  square<typename vtr_colln_t::value_type>::last=0;
302  auto const &context=pool<<joinable()<<cliques(1)<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
303  pool.min_time(vtr_colln_t::memory_access_mode);
304  pool.min_processors(vtr_colln_t::memory_access_mode);
305  *context;
306  BOOST_CHECK_EQUAL(v.empty(), true);
307  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 0);
308 }
309 
310 BOOST_AUTO_TEST_CASE_TEMPLATE(overlapped_write_held_by_reads, T, finite_test_types) {
311  typedef typename T::vtr_colln_t vtr_colln_t;
312  typedef typename T::pool_type pool_type;
313  typedef typename pool_type::joinable joinable;
314 
315  pool_type pool(T::pool_size);
316  vtr_colln_t v;
317  square<typename vtr_colln_t::value_type>::last=0;
318  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
319  v.clear();
320  *context;
321  BOOST_CHECK_EQUAL(v.empty(), true);
322  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 0);
323 }
324 
325 BOOST_AUTO_TEST_CASE_TEMPLATE(count, T, finite_test_types) {
326  typedef typename T::vtr_colln_t vtr_colln_t;
327  typedef typename T::pool_type pool_type;
328  typedef typename pool_type::joinable joinable;
329 
330  pool_type pool(T::pool_size);
331  vtr_colln_t v;
332  auto const &context=pool<<joinable()<<pool.count(v,1);
333  pool.min_time(vtr_colln_t::memory_access_mode);
334  pool.min_processors(vtr_colln_t::memory_access_mode);
335  BOOST_CHECK_EQUAL(*context, 0U);
336  BOOST_CHECK_EQUAL(v.empty(), true);
337  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
338  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
339 }
340 
341 BOOST_AUTO_TEST_CASE_TEMPLATE(count_if, T, finite_test_types) {
342  typedef typename T::vtr_colln_t vtr_colln_t;
343  typedef typename T::pool_type pool_type;
344  typedef typename pool_type::joinable joinable;
345 
346  pool_type pool(T::pool_size);
347  vtr_colln_t v;
348  auto const &context=pool<<joinable()<<pool.count_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(),1));
349  pool.min_time(vtr_colln_t::memory_access_mode);
350  pool.min_processors(vtr_colln_t::memory_access_mode);
351  BOOST_CHECK_EQUAL(*context, 0U);
352  BOOST_CHECK_EQUAL(v.empty(), true);
353  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
354  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
355 }
356 
357 BOOST_AUTO_TEST_CASE_TEMPLATE(find, T, finite_test_types) {
358  typedef typename T::vtr_colln_t vtr_colln_t;
359  typedef typename T::pool_type pool_type;
360  typedef typename pool_type::joinable joinable;
361 
362  pool_type pool(T::pool_size);
363  vtr_colln_t v;
364  auto const &context=pool<<joinable()<<pool.find(v,1);
365  pool.min_time(vtr_colln_t::memory_access_mode);
366  pool.min_processors(vtr_colln_t::memory_access_mode);
367  BOOST_CHECK_EQUAL(*context, false);
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_CASE_TEMPLATE(find_if, T, finite_test_types) {
374  typedef typename T::vtr_colln_t vtr_colln_t;
375  typedef typename T::pool_type pool_type;
376  typedef typename pool_type::joinable joinable;
377 
378  pool_type pool(T::pool_size);
379  vtr_colln_t v;
380  auto const &context=pool<<joinable()<<pool.find_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(),1));
381  pool.min_time(vtr_colln_t::memory_access_mode);
382  pool.min_processors(vtr_colln_t::memory_access_mode);
383  BOOST_CHECK_EQUAL(*context, false);
384  BOOST_CHECK_EQUAL(v.empty(), true);
385  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
386  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
387 }
388 
389 BOOST_AUTO_TEST_SUITE_END()
390 
391 BOOST_AUTO_TEST_SUITE(nonempty_colln)
392 
393 BOOST_AUTO_TEST_SUITE(one_element)
394 
395 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each, 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;
402  v.push_back(1);
403  square<typename vtr_colln_t::value_type>::last=0;
404  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
405  pool.min_time(vtr_colln_t::memory_access_mode);
406  pool.min_processors(vtr_colln_t::memory_access_mode);
407  *context;
408  BOOST_CHECK_EQUAL(pool.queue_size(), 0U);
409  BOOST_CHECK_EQUAL(v.size(), 1U);
410  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 1);
411 }
412 
413 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each_cliques_1, T, finite_test_types) {
414  typedef typename T::vtr_colln_t vtr_colln_t;
415  typedef typename T::pool_type pool_type;
416  typedef typename pool_type::joinable joinable;
417 
418  pool_type pool(T::pool_size);
419  vtr_colln_t v;
420  v.push_back(1);
421  square<typename vtr_colln_t::value_type>::last=0;
422  auto const &context=pool<<joinable()<<cliques(1)<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
423  pool.min_time(vtr_colln_t::memory_access_mode);
424  pool.min_processors(vtr_colln_t::memory_access_mode);
425  *context;
426  BOOST_CHECK_EQUAL(pool.queue_size(), 0U);
427  BOOST_CHECK_EQUAL(v.size(), 1U);
428  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 1);
429 }
430 
431 BOOST_AUTO_TEST_CASE_TEMPLATE(overlapped_write_held_by_reads, T, finite_test_types) {
432  typedef typename T::vtr_colln_t vtr_colln_t;
433  typedef typename T::pool_type pool_type;
434  typedef typename pool_type::joinable joinable;
435 
436  pool_type pool(T::pool_size);
437  vtr_colln_t v;
438  v.push_back(1);
439  square<typename vtr_colln_t::value_type>::last=0;
440  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
441  v.clear();
442  *context;
443  BOOST_CHECK_EQUAL(v.empty(), true);
444  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 1);
445 }
446 
447 BOOST_AUTO_TEST_CASE_TEMPLATE(count, T, finite_test_types) {
448  typedef typename T::vtr_colln_t vtr_colln_t;
449  typedef typename T::pool_type pool_type;
450  typedef typename pool_type::joinable joinable;
451 
452  pool_type pool(T::pool_size);
453  vtr_colln_t v;
454  v.push_back(1);
455  auto const &context=pool<<joinable()<<pool.count(v, 1);
456  pool.min_time(vtr_colln_t::memory_access_mode);
457  pool.min_processors(vtr_colln_t::memory_access_mode);
458  BOOST_CHECK_EQUAL(*context, 1U);
459  BOOST_CHECK_EQUAL(v.size(), 1U);
460 }
461 
462 BOOST_AUTO_TEST_CASE_TEMPLATE(count_if, T, finite_test_types) {
463  typedef typename T::vtr_colln_t vtr_colln_t;
464  typedef typename T::pool_type pool_type;
465  typedef typename pool_type::joinable joinable;
466 
467  pool_type pool(T::pool_size);
468  vtr_colln_t v;
469  v.push_back(1);
470  auto const &context=pool<<joinable()<<pool.count_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
471  pool.min_time(vtr_colln_t::memory_access_mode);
472  pool.min_processors(vtr_colln_t::memory_access_mode);
473  BOOST_CHECK_EQUAL(*context, 0U);
474  BOOST_CHECK_EQUAL(v.size(), 1U);
475 }
476 
477 BOOST_AUTO_TEST_CASE_TEMPLATE(find, T, finite_test_types) {
478  typedef typename T::vtr_colln_t vtr_colln_t;
479  typedef typename T::pool_type pool_type;
480  typedef typename pool_type::joinable joinable;
481 
482  pool_type pool(T::pool_size);
483  vtr_colln_t v;
484  v.push_back(1);
485  auto const &context=pool<<joinable()<<pool.find(v,1);
486  pool.min_time(vtr_colln_t::memory_access_mode);
487  pool.min_processors(vtr_colln_t::memory_access_mode);
488  BOOST_CHECK_EQUAL(*context, true);
489  BOOST_CHECK_EQUAL(v.size(), 1U);
490 }
491 
492 BOOST_AUTO_TEST_CASE_TEMPLATE(find_if, T, finite_test_types) {
493  typedef typename T::vtr_colln_t vtr_colln_t;
494  typedef typename T::pool_type pool_type;
495  typedef typename pool_type::joinable joinable;
496 
497  pool_type pool(T::pool_size);
498  vtr_colln_t v;
499  v.push_back(1);
500  auto const &context=pool<<joinable()<<pool.find_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
501  pool.min_time(vtr_colln_t::memory_access_mode);
502  pool.min_processors(vtr_colln_t::memory_access_mode);
503  BOOST_CHECK_EQUAL(*context, false);
504  BOOST_CHECK_EQUAL(v.size(), 1U);
505 }
506 
507 BOOST_AUTO_TEST_SUITE_END()
508 
509 BOOST_AUTO_TEST_SUITE(two_elements)
510 
511 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each, T, finite_test_types) {
512  typedef typename T::vtr_colln_t vtr_colln_t;
513  typedef typename T::pool_type pool_type;
514  typedef typename pool_type::joinable joinable;
515 
516  pool_type pool(T::pool_size);
517  vtr_colln_t v;
518  v.push_back(1);
519  v.push_back(2);
520  square<typename vtr_colln_t::value_type>::last=0;
521  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
522  pool.min_time(vtr_colln_t::memory_access_mode);
523  pool.min_processors(vtr_colln_t::memory_access_mode);
524  *context;
525  BOOST_CHECK_EQUAL(v.size(), 2U);
526  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 3);
527 }
528 
529 BOOST_AUTO_TEST_CASE_TEMPLATE(overlapped_write_held_by_reads, T, finite_test_types) {
530  typedef typename T::vtr_colln_t vtr_colln_t;
531  typedef typename T::pool_type pool_type;
532  typedef typename pool_type::joinable joinable;
533 
534  pool_type pool(T::pool_size);
535  vtr_colln_t v;
536  v.push_back(1);
537  v.push_back(2);
538  square<typename vtr_colln_t::value_type>::last=0;
539  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
540  v.clear();
541  *context;
542  BOOST_CHECK_EQUAL(v.empty(), true);
543  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 3);
544 }
545 
546 BOOST_AUTO_TEST_CASE_TEMPLATE(count, T, finite_test_types) {
547  typedef typename T::vtr_colln_t vtr_colln_t;
548  typedef typename T::pool_type pool_type;
549  typedef typename pool_type::joinable joinable;
550 
551  pool_type pool(T::pool_size);
552  vtr_colln_t v;
553  v.push_back(1);
554  v.push_back(2);
555  auto const &context=pool<<joinable()<<pool.count(v,1);
556  pool.min_time(vtr_colln_t::memory_access_mode);
557  pool.min_processors(vtr_colln_t::memory_access_mode);
558  BOOST_CHECK_EQUAL(*context, 1U);
559  BOOST_CHECK_EQUAL(v.size(), 2U);
560 }
561 
562 BOOST_AUTO_TEST_CASE_TEMPLATE(count_if, T, finite_test_types) {
563  typedef typename T::vtr_colln_t vtr_colln_t;
564  typedef typename T::pool_type pool_type;
565  typedef typename pool_type::joinable joinable;
566 
567  pool_type pool(T::pool_size);
568  vtr_colln_t v;
569  v.push_back(1);
570  v.push_back(2);
571  auto const &context=pool<<joinable()<<pool.count_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
572  pool.min_time(vtr_colln_t::memory_access_mode);
573  pool.min_processors(vtr_colln_t::memory_access_mode);
574  BOOST_CHECK_EQUAL(*context, 1U);
575  BOOST_CHECK_EQUAL(v.size(), 2U);
576 }
577 
578 BOOST_AUTO_TEST_CASE_TEMPLATE(find, T, finite_test_types) {
579  typedef typename T::vtr_colln_t vtr_colln_t;
580  typedef typename T::pool_type pool_type;
581  typedef typename pool_type::joinable joinable;
582 
583  pool_type pool(T::pool_size);
584  vtr_colln_t v;
585  v.push_back(1);
586  v.push_back(2);
587  auto const &context=pool<<joinable()<<pool.find(v,1);
588  pool.min_time(vtr_colln_t::memory_access_mode);
589  pool.min_processors(vtr_colln_t::memory_access_mode);
590  BOOST_CHECK_EQUAL(*context, true);
591  BOOST_CHECK_EQUAL(v.size(), 2U);
592 }
593 
594 BOOST_AUTO_TEST_CASE_TEMPLATE(find_if, T, finite_test_types) {
595  typedef typename T::vtr_colln_t vtr_colln_t;
596  typedef typename T::pool_type pool_type;
597  typedef typename pool_type::joinable joinable;
598 
599  pool_type pool(T::pool_size);
600  vtr_colln_t v;
601  v.push_back(1);
602  v.push_back(2);
603  auto const &context=pool<<joinable()<<pool.find_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
604  pool.min_time(vtr_colln_t::memory_access_mode);
605  pool.min_processors(vtr_colln_t::memory_access_mode);
606  BOOST_CHECK_EQUAL(*context, true);
607  BOOST_CHECK_EQUAL(v.size(), 2U);
608 }
609 
610 BOOST_AUTO_TEST_SUITE_END()
611 
612 BOOST_AUTO_TEST_SUITE(n_elements)
613 
614 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each, T, finite_test_types) {
615  typedef typename T::vtr_colln_t vtr_colln_t;
616  typedef typename T::pool_type pool_type;
617  typedef typename pool_type::joinable joinable;
618 
619  pool_type pool(T::pool_size);
620  vtr_colln_t v;
621  v.push_back(1);
622  v.push_back(2);
623  v.push_back(3);
624  v.push_back(4);
625  v.push_back(5);
626  v.push_back(6);
627  v.push_back(7);
628  v.push_back(8);
629  square<typename vtr_colln_t::value_type>::last=0;
630  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
631  pool.min_time(vtr_colln_t::memory_access_mode);
632  pool.min_processors(vtr_colln_t::memory_access_mode);
633  *context;
634  BOOST_CHECK_EQUAL(v.size(), 8U);
635  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 36);
636 }
637 
638 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each_cliques_1, T, finite_test_types) {
639  typedef typename T::vtr_colln_t vtr_colln_t;
640  typedef typename T::pool_type pool_type;
641  typedef typename pool_type::joinable joinable;
642 
643  pool_type pool(T::pool_size);
644  vtr_colln_t v;
645  v.push_back(1);
646  v.push_back(2);
647  v.push_back(3);
648  v.push_back(4);
649  v.push_back(5);
650  v.push_back(6);
651  v.push_back(7);
652  v.push_back(8);
653  square<typename vtr_colln_t::value_type>::last=0;
654  auto const &context=pool<<joinable()<<cliques(1)<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
655  pool.min_time(vtr_colln_t::memory_access_mode);
656  pool.min_processors(vtr_colln_t::memory_access_mode);
657  *context;
658  BOOST_CHECK_EQUAL(v.size(), 8U);
659  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 36);
660 }
661 
662 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each_cliques_2, T, finite_test_types) {
663  typedef typename T::vtr_colln_t vtr_colln_t;
664  typedef typename T::pool_type pool_type;
665  typedef typename pool_type::joinable joinable;
666 
667  pool_type pool(T::pool_size);
668  vtr_colln_t v;
669  v.push_back(1);
670  v.push_back(2);
671  v.push_back(3);
672  v.push_back(4);
673  v.push_back(5);
674  v.push_back(6);
675  v.push_back(7);
676  v.push_back(8);
677  square<typename vtr_colln_t::value_type>::last=0;
678  auto const &context=pool<<joinable()<<cliques(2)<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
679  pool.min_time(vtr_colln_t::memory_access_mode);
680  pool.min_processors(vtr_colln_t::memory_access_mode);
681  *context;
682  BOOST_CHECK_EQUAL(v.size(), 8U);
683  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 36);
684 }
685 
686 BOOST_AUTO_TEST_CASE_TEMPLATE(overlapped_write_held_by_reads, T, finite_test_types) {
687  typedef typename T::vtr_colln_t vtr_colln_t;
688  typedef typename T::pool_type pool_type;
689  typedef typename pool_type::joinable joinable;
690 
691  pool_type pool(T::pool_size);
692  vtr_colln_t v;
693  v.push_back(1);
694  v.push_back(2);
695  v.push_back(3);
696  v.push_back(4);
697  v.push_back(5);
698  v.push_back(6);
699  v.push_back(7);
700  v.push_back(8);
701  square<typename vtr_colln_t::value_type>::last=0;
702  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
703  v.clear();
704  *context;
705  BOOST_CHECK_EQUAL(v.empty(), true);
706  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 36);
707 }
708 
709 BOOST_AUTO_TEST_CASE_TEMPLATE(count, T, finite_test_types) {
710  typedef typename T::vtr_colln_t vtr_colln_t;
711  typedef typename T::pool_type pool_type;
712  typedef typename pool_type::joinable joinable;
713 
714  pool_type pool(T::pool_size);
715  vtr_colln_t v;
716  v.push_back(1);
717  v.push_back(2);
718  v.push_back(1);
719  v.push_back(4);
720  v.push_back(5);
721  v.push_back(6);
722  v.push_back(7);
723  v.push_back(8);
724  auto const &context=pool<<joinable()<<pool.count(v,1);
725  pool.min_time(vtr_colln_t::memory_access_mode);
726  pool.min_processors(vtr_colln_t::memory_access_mode);
727  BOOST_CHECK_EQUAL(*context, 2U);
728  BOOST_CHECK_EQUAL(v.size(), 8U);
729 }
730 
731 BOOST_AUTO_TEST_CASE_TEMPLATE(count_if, T, finite_test_types) {
732  typedef typename T::vtr_colln_t vtr_colln_t;
733  typedef typename T::pool_type pool_type;
734  typedef typename pool_type::joinable joinable;
735 
736  pool_type pool(T::pool_size);
737  vtr_colln_t v;
738  v.push_back(1);
739  v.push_back(2);
740  v.push_back(1);
741  v.push_back(4);
742  v.push_back(5);
743  v.push_back(6);
744  v.push_back(7);
745  v.push_back(8);
746  auto const &context=pool<<joinable()<<pool.count_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
747  pool.min_time(vtr_colln_t::memory_access_mode);
748  pool.min_processors(vtr_colln_t::memory_access_mode);
749  BOOST_CHECK_EQUAL(*context, 6U);
750  BOOST_CHECK_EQUAL(v.size(), 8U);
751 }
752 
753 BOOST_AUTO_TEST_CASE_TEMPLATE(find, T, finite_test_types) {
754  typedef typename T::vtr_colln_t vtr_colln_t;
755  typedef typename T::pool_type pool_type;
756  typedef typename pool_type::joinable joinable;
757 
758  pool_type pool(T::pool_size);
759  vtr_colln_t v;
760  v.push_back(1);
761  v.push_back(2);
762  v.push_back(1);
763  v.push_back(4);
764  v.push_back(5);
765  v.push_back(6);
766  v.push_back(7);
767  v.push_back(8);
768  auto const &context=pool<<joinable()<<pool.find(v,1);
769  pool.min_time(vtr_colln_t::memory_access_mode);
770  pool.min_processors(vtr_colln_t::memory_access_mode);
771  BOOST_CHECK_EQUAL(*context, true);
772  BOOST_CHECK_EQUAL(v.size(), 8U);
773 }
774 
775 BOOST_AUTO_TEST_CASE_TEMPLATE(find_if, T, finite_test_types) {
776  typedef typename T::vtr_colln_t vtr_colln_t;
777  typedef typename T::pool_type pool_type;
778  typedef typename pool_type::joinable joinable;
779 
780  pool_type pool(T::pool_size);
781  vtr_colln_t v;
782  v.push_back(1);
783  v.push_back(2);
784  v.push_back(1);
785  v.push_back(4);
786  v.push_back(5);
787  v.push_back(6);
788  v.push_back(7);
789  v.push_back(8);
790  auto const &context=pool<<joinable()<<pool.find_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
791  pool.min_time(vtr_colln_t::memory_access_mode);
792  pool.min_processors(vtr_colln_t::memory_access_mode);
793  BOOST_CHECK_EQUAL(*context, true);
794  BOOST_CHECK_EQUAL(v.size(), 8U);
795 }
796 
797 BOOST_AUTO_TEST_SUITE_END()
798 
799 BOOST_AUTO_TEST_SUITE_END()
800 
801 BOOST_AUTO_TEST_SUITE_END()
802 
803 BOOST_AUTO_TEST_SUITE(infinite)
804 
805 BOOST_AUTO_TEST_SUITE(empty_colln)
806 
807 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each, T, infinite_test_types) {
808  typedef typename T::vtr_colln_t vtr_colln_t;
809  typedef typename T::pool_type pool_type;
810  typedef typename pool_type::joinable joinable;
811 
812  pool_type pool;
813  vtr_colln_t v;
814  square<typename vtr_colln_t::value_type>::last=0;
815  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
816  pool.min_time(vtr_colln_t::memory_access_mode);
817  pool.min_processors(vtr_colln_t::memory_access_mode);
818  *context;
819  BOOST_CHECK_EQUAL(v.empty(), true);
820  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 0);
821  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
822  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
823 }
824 
825 BOOST_AUTO_TEST_CASE_TEMPLATE(count, T, infinite_test_types) {
826  typedef typename T::vtr_colln_t vtr_colln_t;
827  typedef typename T::pool_type pool_type;
828  typedef typename pool_type::joinable joinable;
829 
830  pool_type pool;
831  vtr_colln_t v;
832  auto const &context=pool<<joinable()<<pool.count(v,1);
833  BOOST_CHECK_EQUAL(*context, 0U);
834  BOOST_CHECK_EQUAL(v.empty(), true);
835  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
836  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
837 }
838 
839 BOOST_AUTO_TEST_CASE_TEMPLATE(count_if, T, infinite_test_types) {
840  typedef typename T::vtr_colln_t vtr_colln_t;
841  typedef typename T::pool_type pool_type;
842  typedef typename pool_type::joinable joinable;
843 
844  pool_type pool;
845  vtr_colln_t v;
846  auto const &context=pool<<joinable()<<pool.count_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
847  pool.min_time(vtr_colln_t::memory_access_mode);
848  pool.min_processors(vtr_colln_t::memory_access_mode);
849  BOOST_CHECK_EQUAL(*context, 0U);
850  BOOST_CHECK_EQUAL(v.empty(), true);
851  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
852  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
853 }
854 
855 BOOST_AUTO_TEST_CASE_TEMPLATE(find, T, infinite_test_types) {
856  typedef typename T::vtr_colln_t vtr_colln_t;
857  typedef typename T::pool_type pool_type;
858  typedef typename pool_type::joinable joinable;
859 
860  pool_type pool;
861  vtr_colln_t v;
862  auto const &context=pool<<joinable()<<pool.find(v,1);
863  pool.min_time(vtr_colln_t::memory_access_mode);
864  pool.min_processors(vtr_colln_t::memory_access_mode);
865  BOOST_CHECK_EQUAL(*context, false);
866  BOOST_CHECK_EQUAL(v.empty(), true);
867  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
868  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
869 }
870 
871 BOOST_AUTO_TEST_CASE_TEMPLATE(find_if, T, infinite_test_types) {
872  typedef typename T::vtr_colln_t vtr_colln_t;
873  typedef typename T::pool_type pool_type;
874  typedef typename pool_type::joinable joinable;
875 
876  pool_type pool;
877  vtr_colln_t v;
878  auto const &context=pool<<joinable()<<pool.find_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
879  pool.min_time(vtr_colln_t::memory_access_mode);
880  pool.min_processors(vtr_colln_t::memory_access_mode);
881  BOOST_CHECK_EQUAL(*context, false);
882  BOOST_CHECK_EQUAL(v.empty(), true);
883  BOOST_CHECK_EQUAL(pool.min_time(context), 0U);
884  BOOST_CHECK_EQUAL(pool.min_processors(context), 0U);
885 }
886 
887 BOOST_AUTO_TEST_SUITE_END()
888 
889 BOOST_AUTO_TEST_SUITE_END()
890 
891 BOOST_AUTO_TEST_SUITE(nonempty_colln)
892 
893 BOOST_AUTO_TEST_SUITE(one_element)
894 
895 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each, T, infinite_test_types) {
896  typedef typename T::vtr_colln_t vtr_colln_t;
897  typedef typename T::pool_type pool_type;
898  typedef typename pool_type::joinable joinable;
899 
900  pool_type pool;
901  vtr_colln_t v;
902  v.push_back(1);
903  square<typename vtr_colln_t::value_type>::last=0;
904  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
905  pool.min_time(vtr_colln_t::memory_access_mode);
906  pool.min_processors(vtr_colln_t::memory_access_mode);
907  *context;
908  BOOST_CHECK_EQUAL(v.size(), 1U);
909  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 1);
910 }
911 
912 BOOST_AUTO_TEST_CASE_TEMPLATE(count, 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  v.push_back(1);
920  auto const &context=pool<<joinable()<<pool.count(v,1);
921  pool.min_time(vtr_colln_t::memory_access_mode);
922  pool.min_processors(vtr_colln_t::memory_access_mode);
923  BOOST_CHECK_EQUAL(*context, 1U);
924  BOOST_CHECK_EQUAL(v.size(), 1U);
925 }
926 
927 BOOST_AUTO_TEST_CASE_TEMPLATE(count_if, T, infinite_test_types) {
928  typedef typename T::vtr_colln_t vtr_colln_t;
929  typedef typename T::pool_type pool_type;
930  typedef typename pool_type::joinable joinable;
931 
932  pool_type pool;
933  vtr_colln_t v;
934  v.push_back(1);
935  auto const &context=pool<<joinable()<<pool.count_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
936  pool.min_time(vtr_colln_t::memory_access_mode);
937  pool.min_processors(vtr_colln_t::memory_access_mode);
938  BOOST_CHECK_EQUAL(*context, 0U);
939  BOOST_CHECK_EQUAL(v.size(), 1U);
940 }
941 
942 BOOST_AUTO_TEST_CASE_TEMPLATE(find, T, infinite_test_types) {
943  typedef typename T::vtr_colln_t vtr_colln_t;
944  typedef typename T::pool_type pool_type;
945  typedef typename pool_type::joinable joinable;
946 
947  pool_type pool;
948  vtr_colln_t v;
949  v.push_back(1);
950  auto const &context=pool<<joinable()<<pool.find(v,1);
951  pool.min_time(vtr_colln_t::memory_access_mode);
952  pool.min_processors(vtr_colln_t::memory_access_mode);
953  BOOST_CHECK_EQUAL(*context, true);
954  BOOST_CHECK_EQUAL(v.size(), 1U);
955 }
956 
957 BOOST_AUTO_TEST_CASE_TEMPLATE(find_if, T, infinite_test_types) {
958  typedef typename T::vtr_colln_t vtr_colln_t;
959  typedef typename T::pool_type pool_type;
960  typedef typename pool_type::joinable joinable;
961 
962  pool_type pool;
963  vtr_colln_t v;
964  v.push_back(1);
965  auto const &context=pool<<joinable()<<pool.find_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
966  pool.min_time(vtr_colln_t::memory_access_mode);
967  pool.min_processors(vtr_colln_t::memory_access_mode);
968  BOOST_CHECK_EQUAL(*context, false);
969  BOOST_CHECK_EQUAL(v.size(), 1U);
970 }
971 
972 BOOST_AUTO_TEST_SUITE_END()
973 
974 BOOST_AUTO_TEST_SUITE(two_elements)
975 
976 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each, T, infinite_test_types) {
977  typedef typename T::vtr_colln_t vtr_colln_t;
978  typedef typename T::pool_type pool_type;
979  typedef typename pool_type::joinable joinable;
980 
981  pool_type pool;
982  vtr_colln_t v;
983  v.push_back(1);
984  v.push_back(2);
985  square<typename vtr_colln_t::value_type>::last=0;
986  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
987  pool.min_time(vtr_colln_t::memory_access_mode);
988  pool.min_processors(vtr_colln_t::memory_access_mode);
989  *context;
990  BOOST_CHECK_EQUAL(v.size(), 2U);
991  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 3);
992 }
993 
994 BOOST_AUTO_TEST_CASE_TEMPLATE(count, T, infinite_test_types) {
995  typedef typename T::vtr_colln_t vtr_colln_t;
996  typedef typename T::pool_type pool_type;
997  typedef typename pool_type::joinable joinable;
998 
999  pool_type pool;
1000  vtr_colln_t v;
1001  v.push_back(1);
1002  v.push_back(2);
1003  auto const &context=pool<<joinable()<<pool.count(v,1);
1004  pool.min_time(vtr_colln_t::memory_access_mode);
1005  pool.min_processors(vtr_colln_t::memory_access_mode);
1006  BOOST_CHECK_EQUAL(*context, 1U);
1007  BOOST_CHECK_EQUAL(v.size(), 2U);
1008 }
1009 
1010 BOOST_AUTO_TEST_CASE_TEMPLATE(count_if, T, infinite_test_types) {
1011  typedef typename T::vtr_colln_t vtr_colln_t;
1012  typedef typename T::pool_type pool_type;
1013  typedef typename pool_type::joinable joinable;
1014 
1015  pool_type pool;
1016  vtr_colln_t v;
1017  v.push_back(1);
1018  v.push_back(2);
1019  auto const &context=pool<<joinable()<<pool.count_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
1020  pool.min_time(vtr_colln_t::memory_access_mode);
1021  pool.min_processors(vtr_colln_t::memory_access_mode);
1022  BOOST_CHECK_EQUAL(*context, 1U);
1023  BOOST_CHECK_EQUAL(v.size(), 2U);
1024 }
1025 
1026 BOOST_AUTO_TEST_CASE_TEMPLATE(find, T, infinite_test_types) {
1027  typedef typename T::vtr_colln_t vtr_colln_t;
1028  typedef typename T::pool_type pool_type;
1029  typedef typename pool_type::joinable joinable;
1030 
1031  pool_type pool;
1032  vtr_colln_t v;
1033  v.push_back(1);
1034  v.push_back(2);
1035  auto const &context=pool<<joinable()<<pool.find(v,1);
1036  pool.min_time(vtr_colln_t::memory_access_mode);
1037  pool.min_processors(vtr_colln_t::memory_access_mode);
1038  BOOST_CHECK_EQUAL(*context, true);
1039  BOOST_CHECK_EQUAL(v.size(), 2U);
1040 }
1041 
1042 BOOST_AUTO_TEST_CASE_TEMPLATE(find_if, T, infinite_test_types) {
1043  typedef typename T::vtr_colln_t vtr_colln_t;
1044  typedef typename T::pool_type pool_type;
1045  typedef typename pool_type::joinable joinable;
1046 
1047  pool_type pool;
1048  vtr_colln_t v;
1049  v.push_back(1);
1050  v.push_back(2);
1051  auto const &context=pool<<joinable()<<pool.find_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
1052  pool.min_time(vtr_colln_t::memory_access_mode);
1053  pool.min_processors(vtr_colln_t::memory_access_mode);
1054  BOOST_CHECK_EQUAL(*context, true);
1055  BOOST_CHECK_EQUAL(v.size(), 2U);
1056 }
1057 
1058 BOOST_AUTO_TEST_SUITE_END()
1059 
1060 BOOST_AUTO_TEST_SUITE(n_elements)
1061 
1062 BOOST_AUTO_TEST_CASE_TEMPLATE(for_each, T, infinite_test_types) {
1063  typedef typename T::vtr_colln_t vtr_colln_t;
1064  typedef typename T::pool_type pool_type;
1065  typedef typename pool_type::joinable joinable;
1066 
1067  pool_type pool;
1068  vtr_colln_t v;
1069  v.push_back(1);
1070  v.push_back(2);
1071  v.push_back(3);
1072  v.push_back(4);
1073  v.push_back(5);
1074  v.push_back(6);
1075  v.push_back(7);
1076  v.push_back(8);
1077  square<typename vtr_colln_t::value_type>::last=0;
1078  auto const &context=pool<<joinable()<<pool.for_each(v, square<typename vtr_colln_t::value_type>());
1079  pool.min_time(vtr_colln_t::memory_access_mode);
1080  pool.min_processors(vtr_colln_t::memory_access_mode);
1081  *context;
1082  BOOST_CHECK_EQUAL(v.size(), 8U);
1083  BOOST_CHECK_EQUAL(square<typename vtr_colln_t::value_type>::last, 36);
1084 }
1085 
1086 BOOST_AUTO_TEST_CASE_TEMPLATE(count, T, infinite_test_types) {
1087  typedef typename T::vtr_colln_t vtr_colln_t;
1088  typedef typename T::pool_type pool_type;
1089  typedef typename pool_type::joinable joinable;
1090 
1091  pool_type pool;
1092  vtr_colln_t v;
1093  v.push_back(1);
1094  v.push_back(2);
1095  v.push_back(1);
1096  v.push_back(4);
1097  v.push_back(5);
1098  v.push_back(6);
1099  v.push_back(7);
1100  v.push_back(8);
1101  auto const &context=pool<<joinable()<<pool.count(v,1);
1102  pool.min_time(vtr_colln_t::memory_access_mode);
1103  pool.min_processors(vtr_colln_t::memory_access_mode);
1104  BOOST_CHECK_EQUAL(*context, 2U);
1105  BOOST_CHECK_EQUAL(v.size(), 8U);
1106 }
1107 
1108 BOOST_AUTO_TEST_CASE_TEMPLATE(count_if, 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  v.push_back(1);
1118  v.push_back(4);
1119  v.push_back(5);
1120  v.push_back(6);
1121  v.push_back(7);
1122  v.push_back(8);
1123  auto const &context=pool<<joinable()<<pool.count_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
1124  pool.min_time(vtr_colln_t::memory_access_mode);
1125  pool.min_processors(vtr_colln_t::memory_access_mode);
1126  BOOST_CHECK_EQUAL(*context, 6U);
1127  BOOST_CHECK_EQUAL(v.size(), 8U);
1128 }
1129 
1130 BOOST_AUTO_TEST_CASE_TEMPLATE(find, T, infinite_test_types) {
1131  typedef typename T::vtr_colln_t vtr_colln_t;
1132  typedef typename T::pool_type pool_type;
1133  typedef typename pool_type::joinable joinable;
1134 
1135  pool_type pool;
1136  vtr_colln_t v;
1137  v.push_back(1);
1138  v.push_back(2);
1139  v.push_back(1);
1140  v.push_back(4);
1141  v.push_back(5);
1142  v.push_back(6);
1143  v.push_back(7);
1144  v.push_back(8);
1145  auto const &context=pool<<joinable()<<pool.find(v,1);
1146  pool.min_time(vtr_colln_t::memory_access_mode);
1147  pool.min_processors(vtr_colln_t::memory_access_mode);
1148  BOOST_CHECK_EQUAL(*context, true);
1149  BOOST_CHECK_EQUAL(v.size(), 8U);
1150 }
1151 
1152 BOOST_AUTO_TEST_CASE_TEMPLATE(find_if, T, infinite_test_types) {
1153  typedef typename T::vtr_colln_t vtr_colln_t;
1154  typedef typename T::pool_type pool_type;
1155  typedef typename pool_type::joinable joinable;
1156 
1157  pool_type pool;
1158  vtr_colln_t v;
1159  v.push_back(1);
1160  v.push_back(2);
1161  v.push_back(1);
1162  v.push_back(4);
1163  v.push_back(5);
1164  v.push_back(6);
1165  v.push_back(7);
1166  v.push_back(8);
1167  auto const &context=pool<<joinable()<<pool.find_if(v, std::bind2nd(std::not_equal_to<typename vtr_colln_t::value_type>(), 1));
1168  pool.min_time(vtr_colln_t::memory_access_mode);
1169  pool.min_processors(vtr_colln_t::memory_access_mode);
1170  BOOST_CHECK_EQUAL(*context, true);
1171  BOOST_CHECK_EQUAL(v.size(), 8U);
1172 }
1173 
1174 BOOST_AUTO_TEST_SUITE_END()
1175 
1176 BOOST_AUTO_TEST_SUITE_END()
1177 
1178 BOOST_AUTO_TEST_SUITE_END()
1179 
1180 BOOST_AUTO_TEST_SUITE_END()