Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r56774 - in sandbox/async: boost boost/tp boost/tp/detail libs/tp libs/tp/build libs/tp/doc libs/tp/doc/html libs/tp/doc/html/boost_threadpool libs/tp/examples libs/tp/src libs/tp/test
From: vicente.botet_at_[hidden]
Date: 2009-10-13 03:35:37

Author: viboes
Date: 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
New Revision: 56774
URL: http://svn.boost.org/trac/boost/changeset/56774

Log:
TBoost.Async:
* Added ThreadPool library

Added:
   sandbox/async/boost/tp/
   sandbox/async/boost/tp.hpp (contents, props changed)
   sandbox/async/boost/tp/bounded_channel.hpp (contents, props changed)
   sandbox/async/boost/tp/default_pool.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/
   sandbox/async/boost/tp/detail/bind_processor.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/bind_processor_aix.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/bind_processor_hpux.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/bind_processor_irix.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/bind_processor_linux.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/bind_processor_solaris.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/bind_processor_windows.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/callable.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/guard.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/info.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/interrupter.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/worker.hpp (contents, props changed)
   sandbox/async/boost/tp/detail/wsq.hpp (contents, props changed)
   sandbox/async/boost/tp/exceptions.hpp (contents, props changed)
   sandbox/async/boost/tp/fifo.hpp (contents, props changed)
   sandbox/async/boost/tp/info.hpp (contents, props changed)
   sandbox/async/boost/tp/lifo.hpp (contents, props changed)
   sandbox/async/boost/tp/pool.hpp (contents, props changed)
   sandbox/async/boost/tp/poolsize.hpp (contents, props changed)
   sandbox/async/boost/tp/priority.hpp (contents, props changed)
   sandbox/async/boost/tp/scanns.hpp (contents, props changed)
   sandbox/async/boost/tp/smart.hpp (contents, props changed)
   sandbox/async/boost/tp/task.hpp (contents, props changed)
   sandbox/async/boost/tp/unbounded_channel.hpp (contents, props changed)
   sandbox/async/boost/tp/watermark.hpp (contents, props changed)
   sandbox/async/libs/tp/
   sandbox/async/libs/tp/build/
   sandbox/async/libs/tp/build/Jamfile.v2 (contents, props changed)
   sandbox/async/libs/tp/doc/
   sandbox/async/libs/tp/doc/Jamfile.v2 (contents, props changed)
   sandbox/async/libs/tp/doc/acknowledgement.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/channel.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/exceptions_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/forkjoin.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/html/
   sandbox/async/libs/tp/doc/html/boost_threadpool/
   sandbox/async/libs/tp/doc/html/boost_threadpool/acknowledgement.html (contents, props changed)
   sandbox/async/libs/tp/doc/html/boost_threadpool/channel.html (contents, props changed)
   sandbox/async/libs/tp/doc/html/boost_threadpool/forkjoin.html (contents, props changed)
   sandbox/async/libs/tp/doc/html/boost_threadpool/pool.html (contents, props changed)
   sandbox/async/libs/tp/doc/html/boost_threadpool/reference.html (contents, props changed)
   sandbox/async/libs/tp/doc/html/boost_threadpool/scheduling.html (contents, props changed)
   sandbox/async/libs/tp/doc/html/boost_threadpool/task.html (contents, props changed)
   sandbox/async/libs/tp/doc/html/boost_threadpool/this_task.html (contents, props changed)
   sandbox/async/libs/tp/doc/html/index.html (contents, props changed)
   sandbox/async/libs/tp/doc/introduction.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/meta_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/pool.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/pool_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/poolsize_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/reference.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/scanns_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/scheduling.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/stacksize_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/task.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/task_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/this_task.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/this_task_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/threadpool.qbk (contents, props changed)
   sandbox/async/libs/tp/doc/threadpool.xml (contents, props changed)
   sandbox/async/libs/tp/doc/watermark_ref.qbk (contents, props changed)
   sandbox/async/libs/tp/examples/
   sandbox/async/libs/tp/examples/Jamfile.v2 (contents, props changed)
   sandbox/async/libs/tp/examples/fork_join.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/interrupt.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/parallel_sort.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/pending.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/priority.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/reschedule_until.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/shutdonw_now.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/smart.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/spread_over_hardware.cpp (contents, props changed)
   sandbox/async/libs/tp/examples/submit.cpp (contents, props changed)
   sandbox/async/libs/tp/src/
   sandbox/async/libs/tp/src/callable.cpp (contents, props changed)
   sandbox/async/libs/tp/src/default_pool.cpp (contents, props changed)
   sandbox/async/libs/tp/src/guard.cpp (contents, props changed)
   sandbox/async/libs/tp/src/interrupter.cpp (contents, props changed)
   sandbox/async/libs/tp/src/poolsize.cpp (contents, props changed)
   sandbox/async/libs/tp/src/scanns.cpp (contents, props changed)
   sandbox/async/libs/tp/src/watermark.cpp (contents, props changed)
   sandbox/async/libs/tp/src/worker.cpp (contents, props changed)
   sandbox/async/libs/tp/test/
   sandbox/async/libs/tp/test/Jamfile.v2 (contents, props changed)
   sandbox/async/libs/tp/test/test_bounded_queue_fifo.cpp (contents, props changed)
   sandbox/async/libs/tp/test/test_bounded_queue_lifo.cpp (contents, props changed)
   sandbox/async/libs/tp/test/test_bounded_queue_priority.cpp (contents, props changed)
   sandbox/async/libs/tp/test/test_bounded_queue_smart.cpp (contents, props changed)
   sandbox/async/libs/tp/test/test_functions.hpp (contents, props changed)
   sandbox/async/libs/tp/test/test_unbounded_queue_fifo.cpp (contents, props changed)
   sandbox/async/libs/tp/test/test_unbounded_queue_lifo.cpp (contents, props changed)
   sandbox/async/libs/tp/test/test_unbounded_queue_priority.cpp (contents, props changed)
   sandbox/async/libs/tp/test/test_unbounded_queue_smart.cpp (contents, props changed)

Added: sandbox/async/boost/tp.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,23 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_H
+#define BOOST_TP_H
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/fifo.hpp>
+#include <boost/tp/info.hpp>
+#include <boost/tp/lifo.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/priority.hpp>
+#include <boost/tp/scanns.hpp>
+#include <boost/tp/smart.hpp>
+#include <boost/tp/task.hpp>
+#include <boost/tp/unbounded_channel.hpp>
+#include <boost/tp/watermark.hpp>
+
+#endif // BOOST_TP_H
+

Added: sandbox/async/boost/tp/bounded_channel.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/bounded_channel.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,409 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_BOUNDED_CHANNEL_H
+#define BOOST_TP_BOUNDED_CHANNEL_H
+
+#include <cstddef>
+#include <vector>
+
+#include <boost/assert.hpp>
+#include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+#include <boost/function.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+#include <boost/tp/detail/callable.hpp>
+#include <boost/tp/detail/interrupter.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/watermark.hpp>
+
+namespace boost { namespace tp
+{
+template< typename SchedulingPolicy >
+class bounded_channel
+{
+private:
+ typedef SchedulingPolicy scheduling_policy;
+ typedef typename scheduling_policy::template impl<
+ detail::callable
+ > queue;
+
+public:
+ typedef typename queue::item item;
+ typedef scheduling_policy scheduler_type;
+
+private:
+ enum channel_state
+ {
+ channel_active,
+ channel_deactive,
+ channel_deactive_now
+ };
+
+ channel_state state_;
+ queue queue_;
+ shared_mutex mtx_;
+ condition not_empty_cond_;
+ condition not_full_cond_;
+ std::size_t hwm_;
+ std::size_t lwm_;
+
+ bool active_() const
+ { return state_ == channel_active; }
+
+ bool deactive_() const
+ { return state_ == channel_deactive; }
+
+ bool deactive_now_() const
+ { return state_ == channel_deactive_now; }
+
+ void activate_()
+ { state_ = channel_active; }
+
+ void clear_()
+ {
+ BOOST_ASSERT( ! active_() );
+ queue_.clear();
+ BOOST_ASSERT( empty_() );
+ }
+
+ void deactivate_()
+ {
+ if ( active_() )
+ {
+ state_ = channel_deactive;
+ not_empty_cond_.notify_all();
+ }
+
+ BOOST_ASSERT( deactive_() );
+ }
+
+ void deactivate_now_()
+ {
+ if ( active_() )
+ {
+ state_ = channel_deactive_now;
+ not_empty_cond_.notify_all();
+ }
+
+ BOOST_ASSERT( deactive_now_() );
+ }
+
+ const std::vector< detail::callable > drain_()
+ {
+ BOOST_ASSERT( deactive_now_() );
+ std::vector< detail::callable > unprocessed;
+ unprocessed.reserve( queue_.size() );
+ BOOST_FOREACH( item itm, queue_)
+ { unprocessed.push_back( itm.ca() ); }
+ clear_();
+ BOOST_ASSERT( empty_() );
+ return unprocessed;
+ }
+
+ bool empty_() const
+ { return queue_.empty(); }
+
+ bool full_() const
+ { return size_() >= hwm_; }
+
+ std::size_t size_() const
+ { return queue_.size(); }
+
+ void upper_bound_( std::size_t hwm)
+ {
+ if ( lwm_ > hwm )
+ throw invalid_watermark("low watermark must be less than or equal to high watermark");
+ std::size_t tmp( hwm_);
+ hwm_ = hwm;
+ if ( hwm_ > tmp) not_full_cond_.notify_one();
+ }
+
+ void lower_bound_( std::size_t lwm)
+ {
+ if ( lwm > hwm_ )
+ throw invalid_watermark("low watermark must be less than or equal to high watermark");
+ std::size_t tmp( lwm_);
+ lwm_ = lwm;
+ if ( lwm_ > tmp) not_full_cond_.notify_one();
+ }
+
+ void put_(
+ item const& itm,
+ unique_lock< shared_mutex > & lk)
+ {
+ not_full_cond_.wait(
+ lk,
+ bind(
+ & bounded_channel::producers_activate_,
+ this) );
+ if ( ! active_() )
+ throw task_rejected("channel is not active");
+ queue_.push( itm);
+ not_empty_cond_.notify_one();
+ }
+
+ template< typename Duration >
+ void put_(
+ item const& itm,
+ Duration const& rel_time,
+ unique_lock< shared_mutex > & lk)
+ {
+ if ( ! not_full_cond_.timed_wait(
+ lk,
+ rel_time,
+ bind(
+ & bounded_channel::producers_activate_,
+ this) ) )
+ throw task_rejected("timed out");
+ if ( ! active_() )
+ throw task_rejected("channel is not active");
+ queue_.push( itm);
+ not_empty_cond_.notify_one();
+ }
+
+ bool take_(
+ detail::callable & ca,
+ detail::interrupter & intr,
+ unique_lock< shared_mutex > & lk)
+ {
+ if ( deactive_now_() || ( deactive_() && empty_() ) )
+ return false;
+ try
+ {
+ not_empty_cond_.wait(
+ lk,
+ bind(
+ & bounded_channel::consumers_activate_,
+ this) );
+ }
+ catch ( thread_interrupted const& e)
+ { return false; }
+ if ( deactive_now_() || ( deactive_() && empty_() ) )
+ return false;
+ item itm( queue_.pop() );
+ ca = itm.ca();
+ intr = itm.intr();
+ if ( size_() <= lwm_)
+ {
+ if ( lwm_ == hwm_)
+ not_full_cond_.notify_one();
+ else
+ // more than one producer could be waiting
+ // for submiting an action object
+ not_full_cond_.notify_all();
+ }
+ return ! ca.empty();
+ }
+
+ template< typename Duration >
+ bool take_(
+ detail::callable & ca,
+ detail::interrupter & intr,
+ Duration const& rel_time,
+ unique_lock< shared_mutex > & lk)
+ {
+ if ( deactive_now_() || ( deactive_() && empty_() ) )
+ return false;
+ try
+ {
+ if ( ! not_empty_cond_.timed_wait(
+ lk,
+ rel_time,
+ bind(
+ & bounded_channel::consumers_activate_,
+ this) ) )
+ return false;
+ }
+ catch ( thread_interrupted const& e)
+ { return false; }
+ if ( deactive_now_() || ( deactive_() && empty_() ) )
+ return false;
+ item itm( queue_.pop() );
+ ca = itm.ca();
+ intr = itm.intr();
+ if ( size_() <= lwm_)
+ {
+ if ( lwm_ == hwm_)
+ not_full_cond_.notify_one();
+ else
+ // more than one producer could be waiting
+ // for submiting an action object
+ not_full_cond_.notify_all();
+ }
+ return ! ca.empty();
+ }
+
+ bool try_take_(
+ detail::callable & ca,
+ detail::interrupter & intr)
+ {
+ if ( deactive_now_() || empty_() )
+ return false;
+ item itm( queue_.pop() );
+ ca = itm.ca();
+ intr = itm.intr();
+ if ( size_() <= lwm_)
+ {
+ if ( lwm_ == hwm_)
+ not_full_cond_.notify_one();
+ else
+ // more than one producer could be waiting
+ // for submiting an action object
+ not_full_cond_.notify_all();
+ }
+ return ! ca.empty();
+ }
+
+ bool producers_activate_() const
+ { return ! active_() || ! full_(); }
+
+ bool consumers_activate_() const
+ { return ! active_() || ! empty_(); }
+
+public:
+ bounded_channel(
+ high_watermark const& hwm,
+ low_watermark const& lwm)
+ :
+ state_( channel_active),
+ queue_(),
+ mtx_(),
+ not_empty_cond_(),
+ not_full_cond_(),
+ hwm_( hwm),
+ lwm_( lwm)
+ {
+ if ( lwm_ > hwm_ )
+ throw invalid_watermark("low watermark must be less than or equal to high watermark");
+ }
+
+ bool active()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return active_();
+ }
+
+ void activate()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ activate_();
+ }
+
+ void clear()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ clear_();
+ }
+
+ bool deactive()
+ { return ! active(); }
+
+ void deactivate()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ deactivate_();
+ }
+
+ void deactivate_now()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ deactivate_now_();
+ }
+
+ const std::vector< detail::callable > drain()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ return drain_();
+ }
+
+ bool empty()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return empty_();
+ }
+
+ bool full()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return full_();
+ }
+
+ std::size_t upper_bound()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return hwm_;
+ }
+
+ void upper_bound( std::size_t hwm)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ upper_bound_( hwm);
+ }
+
+ std::size_t lower_bound()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return lwm_;
+ }
+
+ void lower_bound( std::size_t lwm)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ lower_bound_( lwm);
+ }
+
+ std::size_t size()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return size_();
+ }
+
+ void put( item const& itm)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ put_( itm, lk);
+ }
+
+ template< typename Duration >
+ void put(
+ item const& itm,
+ Duration const& rel_time)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ put_( itm, rel_time, lk);
+ }
+
+ bool take(
+ detail::callable & ca,
+ detail::interrupter & intr)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ return take_( ca, intr, lk);
+ }
+
+ template< typename Duration >
+ bool take(
+ detail::callable & ca,
+ detail::interrupter & intr,
+ Duration const& rel_time)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ return take_( ca, intr, rel_time, lk);
+ }
+
+ bool try_take(
+ detail::callable & ca,
+ detail::interrupter & intr)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ return try_take_( ca, intr);
+ }
+};
+} }
+
+#endif // BOOST_TP_BOUNDED_CHANNEL_H

Added: sandbox/async/boost/tp/default_pool.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/default_pool.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,27 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DEFAULT_POOL_H
+#define BOOST_TP_DEFAULT_POOL_H
+
+#include <boost/tp/fifo.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/unbounded_channel.hpp>
+
+namespace boost { namespace tp
+{
+typedef pool< unbounded_channel< fifo > > default_pool;
+
+namespace detail
+{
+struct static_pool
+{ static default_pool instance; };
+}
+
+inline
+default_pool & get_default_pool()
+{ return detail::static_pool::instance; }
+} }
+
+#endif // BOOST_TP_DEFAULT_POOL_H

Added: sandbox/async/boost/tp/detail/bind_processor.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/bind_processor.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,30 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_THREAD_BIND_PROCESSOR_H
+#define BOOST_THREAD_BIND_PROCESSOR_H
+
+#include <boost/config.hpp>
+
+#define BOOST_THREAD_BIND_PROCESSOR_AFFINITY 1
+
+#if defined(linux) || defined(__linux) || defined(__linux__)
+#include <boost/tp/detail/bind_processor_linux.hpp>
+// #elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+// #include <boost/tp/detail/bind_processor_bsd.hpp>
+#elif defined(sun) || defined(__sun)
+#include <boost/tp/detail/bind_processor_solaris.hpp>
+#elif defined(__sgi)
+#include <boost/tp/detail/bind_processor_irix.hpp>
+#elif defined(__IBMCPP__) || defined(_AIX)
+#include <boost/tp/detail/bind_processor_aix.hpp>
+#elif defined(__hpux)
+#include <boost/tp/detail/bind_processor_hpux.hpp>
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+#include <boost/tp/detail/bind_processor_windows.hpp>
+#else
+#undef BOOST_THREAD_BIND_PROCESSOR_AFFINITY
+#endif
+
+#endif // BOOST_THREAD_BIND_PROCESSOR_H

Added: sandbox/async/boost/tp/detail/bind_processor_aix.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/bind_processor_aix.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,45 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_BIND_PROCESSOR_AIX_H
+#define BOOST_TP_DETAIL_BIND_PROCESSOR_AIX_H
+
+extern "C"
+{
+#include <sys/processor.h>
+#include <sys/thread.h>
+}
+
+#include <boost/assert.hpp>
+#include <boost/thread.hpp>
+#include <boost/system/system_error.hpp>
+
+namespace boost { namespace this_thread
+{
+ inline
+ void bind_to_processor( unsigned int n)
+ {
+ BOOST_ASSERT( n >= 0);
+ BOOST_ASSERT( n < boost::thread::hardware_concurrency() );
+
+ if ( ::bindprocessor( BINDTHREAD, ::thread_self(), static_cast< cpu_t >( n) ) == -1)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno,
+ boost::system::system_category) );
+ }
+
+
+ inline
+ void bind_to_any_processor()
+ {
+ if ( ::bindprocessor( BINDTHREAD, ::thread_self(), PROCESSOR_CLASS_ANY) == -1)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno,
+ boost::system::system_category) );
+ }
+}}
+
+#endif // BOOST_TP_DETAIL_BIND_PROCESSOR_AIX_H

Added: sandbox/async/boost/tp/detail/bind_processor_hpux.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/bind_processor_hpux.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,57 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_BIND_PROCESSOR_HPUX_H
+#define BOOST_TP_DETAIL_BIND_PROCESSOR_HPUX_H
+
+extern "C"
+{
+#include <sys/pthread.h>
+}
+
+#include <boost/assert.hpp>
+#include <boost/thread.hpp>
+#include <boost/system/system_error.hpp>
+
+namespace boost { namespace this_thread
+{
+ inline
+ void bind_to_processor( unsigned int n)
+ {
+ BOOST_ASSERT( n >= 0);
+ BOOST_ASSERT( n < boost::thread::hardware_concurrency() );
+
+ ::pthread_spu_t spu;
+ int errno_(
+ ::pthread_processor_bind_np(
+ PTHREAD_BIND_FORCED_NP,
+ & spu,
+ static_cast< pthread_spu_t >( n),
+ PTHREAD_SELFTID_NP) );
+ if ( errno_ != 0)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno_,
+ boost::system::system_category) );
+ }
+
+ inline
+ void bind_to_any_processor()
+ {
+ ::pthread_spu_t spu;
+ int errno_(
+ ::pthread_processor_bind_np(
+ PTHREAD_BIND_FORCED_NP,
+ & spu,
+ PTHREAD_SPUFLOAT_NP,
+ PTHREAD_SELFTID_NP) );
+ if ( errno_ != 0)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno_,
+ boost::system::system_category) );
+ }
+}}
+
+#endif // BOOST_TP_DETAIL_BIND_PROCESSOR_HPUX_H

Added: sandbox/async/boost/tp/detail/bind_processor_irix.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/bind_processor_irix.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,36 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_BIND_PROCESSOR_IRIX_H
+#define BOOST_TP_DETAIL_BIND_PROCESSOR_IRIX_H
+
+extern "C"
+{
+#include <pthread.h>
+}
+
+#include <boost/assert.hpp>
+#include <boost/thread.hpp>
+#include <boost/system/system_error.hpp>
+
+namespace boost { namespace this_thread
+{
+ inline
+ void bind_to_processor( unsigned int n)
+ {
+ BOOST_ASSERT( n >= 0);
+ BOOST_ASSERT( n < boost::thread::hardware_concurrency() );
+
+ int errno_( ::pthread_setrunon_np( n) );
+ if ( errno_ != 0)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno_,
+ boost::system::system_category) );
+ }
+
+ // bind_to_any_processor() can not be supported
+}}
+
+#endif // BOOST_TP_DETAIL_BIND_PROCESSOR_IRIX_H

Added: sandbox/async/boost/tp/detail/bind_processor_linux.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/bind_processor_linux.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,58 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_BIND_PRCESSOR_LINUX_H
+#define BOOST_TP_DETAIL_BIND_PRCESSOR_LINUX_H
+
+extern "C"
+{
+#include <pthread.h>
+#include <sched.h>
+}
+
+#include <boost/assert.hpp>
+#include <boost/thread.hpp>
+#include <boost/system/system_error.hpp>
+
+namespace boost { namespace this_thread
+{
+ inline
+ void bind_to_processor( unsigned int n)
+ {
+ BOOST_ASSERT( n >= 0);
+ BOOST_ASSERT( n < CPU_SETSIZE);
+ BOOST_ASSERT( n < boost::thread::hardware_concurrency() );
+
+ cpu_set_t cpuset;
+ CPU_ZERO( & cpuset);
+ CPU_SET( n, & cpuset);
+
+ int errno_( ::pthread_setaffinity_np( ::pthread_self(), sizeof( cpuset), & cpuset) );
+ if ( errno_ != 0)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno_,
+ boost::system::system_category) );
+ }
+
+ inline
+ void bind_to_any_processor()
+ {
+ cpu_set_t cpuset;
+ CPU_ZERO( & cpuset);
+
+ unsigned int max( boost::thread::hardware_concurrency() );
+ for ( unsigned int i( 0); i < max; ++i)
+ CPU_SET( i, & cpuset);
+
+ int errno_( ::pthread_setaffinity_np( ::pthread_self(), sizeof( cpuset), & cpuset) );
+ if ( errno_ != 0)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno_,
+ boost::system::system_category) );
+ }
+}}
+
+#endif // BOOST_TP_DETAIL_BIND_PRCESSOR_LINUX_H

Added: sandbox/async/boost/tp/detail/bind_processor_solaris.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/bind_processor_solaris.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,45 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_BIND_PROCESSOR_SOLARIS_H
+#define BOOST_TP_DETAIL_BIND_PROCESSOR_SOLARIS_H
+
+extern "C"
+{
+#include <sys/types.h>
+#include <sys/processor.h>
+#include <sys/procset.h>
+}
+
+#include <boost/assert.hpp>
+#include <boost/thread.hpp>
+#include <boost/system/system_error.hpp>
+
+namespace boost { namespace this_thread
+{
+ inline
+ void bind_to_processor( unsigned int n)
+ {
+ BOOST_ASSERT( n >= 0);
+ BOOST_ASSERT( n < boost::thread::hardware_concurrency() );
+
+ if ( ::processor_bind( P_LWPID, P_MYID, static_cast< processorid_t >( n), 0) == -1)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno,
+ boost::system::system_category) );
+ }
+
+ inline
+ void bind_to_any_processor()
+ {
+ if ( ::processor_bind( P_LWPID, P_MYID, PBIND_NONE, 0) == -1)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ errno,
+ boost::system::system_category) );
+ }
+}}
+
+#endif // BOOST_TP_DETAIL_BIND_PROCESSOR_SOLARIS_H

Added: sandbox/async/boost/tp/detail/bind_processor_windows.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/bind_processor_windows.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,47 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_BIND_PROCESSOR_WINDOWS_H
+#define BOOST_TP_DETAIL_BIND_PROCESSOR_WINDOWS_H
+
+extern "C"
+{
+#include <windows.h>
+}
+
+#include <boost/assert.hpp>
+#include <boost/thread.hpp>
+#include <boost/system/system_error.hpp>
+
+namespace boost { namespace this_thread
+{
+ inline
+ void bind_to_processor( unsigned int n)
+ {
+ BOOST_ASSERT( n >= 0);
+ BOOST_ASSERT( n < boost::thread::hardware_concurrency() );
+
+ if ( ::SetThreadAffinityMask( ::GetCurrentThread(), ( DWORD_PTR)1 << n) == 0)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ ::GetLastError(),
+ boost::system::system_category) );
+ }
+
+ inline
+ void bind_to_any_processor()
+ {
+ DWORD_PTR ptr( 1);
+ for ( unsigned int i( 0); i < boost::thread::hardware_concurrency(); ++i)
+ ptr = ptr << i;
+
+ if ( ::SetThreadAffinityMask( ::GetCurrentThread(), ptr) == 0)
+ throw boost::system::system_error(
+ boost::system::error_code(
+ ::GetLastError(),
+ boost::system::system_category) );
+ }
+}}
+
+#endif // BOOST_TP_DETAIL_BIND_PROCESSOR_WINDOWS_H

Added: sandbox/async/boost/tp/detail/callable.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/callable.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,57 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_CALLABLE_H
+#define BOOST_TP_DETAIL_CALLABLE_H
+
+#include <boost/future.hpp>
+
+#include <boost/thread/detail/move.hpp>
+
+namespace boost { namespace tp {
+namespace detail
+{
+class callable
+{
+private:
+ struct impl
+ {
+ virtual ~impl() {}
+ virtual void run() = 0;
+ };
+
+ template< typename T >
+ struct impl_wrapper
+ : public impl
+ {
+ packaged_task< T > tsk;
+
+ impl_wrapper( boost::detail::thread_move_t< packaged_task< T > > const& t)
+ : tsk( t)
+ {}
+
+ void run()
+ { tsk(); }
+ };
+
+ boost::shared_ptr< impl > impl_;
+
+public:
+ callable();
+
+ template< typename T >
+ callable( boost::detail::thread_move_t< packaged_task< T > > const& t)
+ : impl_( new impl_wrapper< T >( t) )
+ {}
+
+ void operator()();
+
+ bool empty() const;
+
+ void clear();
+};
+} } }
+
+#endif // BOOST_TP_DETAIL_CALLABLE_H
+

Added: sandbox/async/boost/tp/detail/guard.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/guard.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,29 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_GUARD_H
+#define BOOST_TP_DETAIL_GUARD_H
+
+#include <boost/assert.hpp>
+#include <boost/interprocess/detail/atomic.hpp>
+#include <boost/utility.hpp>
+
+namespace boost { namespace tp {
+namespace detail
+{
+class guard
+: private noncopyable
+{
+private:
+ volatile uint32_t & active_worker_;
+
+public:
+ guard( volatile uint32_t & active_worker);
+
+ ~guard();
+};
+} } }
+
+#endif // BOOST_TP_DETAIL_GUARD_H
+

Added: sandbox/async/boost/tp/detail/info.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/info.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,19 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_INFO_H
+#define BOOST_TP_DETAIL_INFO_H
+
+namespace boost { namespace tp {
+namespace detail
+{
+struct has_priority
+{};
+
+struct has_no_priority
+{};
+} } }
+
+#endif // BOOST_TP_DETAIL_INFO_H
+

Added: sandbox/async/boost/tp/detail/interrupter.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/interrupter.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,81 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_INTERRUPTER_H
+#define BOOST_TP_DETAIL_INTERRUPTER_H
+
+#include <boost/shared_ptr.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <boost/utility.hpp>
+
+namespace boost { namespace tp {
+namespace detail
+{
+class interrupter
+{
+private:
+ class impl
+ : private noncopyable
+ {
+ private:
+ bool interruption_requested_;
+ condition_variable cond_;
+ mutex mtx_;
+ shared_ptr< thread > thrd_;
+
+ void interrupt_();
+
+ public:
+ impl();
+
+ void set( shared_ptr< thread > const& thrd);
+
+ void reset();
+
+ void interrupt();
+
+ void interrupt_and_wait();
+
+ void interrupt_and_wait( system_time const& abs_time);
+
+ template< typename DurationType >
+ void interrupt_and_wait( DurationType const& rel_time)
+ {
+ unique_lock< mutex > lk( mtx_);
+ interrupt_();
+ cond_.timed_wait( lk, rel_time);
+ }
+
+ bool interruption_requested();
+ };
+
+ shared_ptr< impl > impl_;
+
+public:
+ interrupter();
+
+ void set( shared_ptr< thread > const& thrd);
+
+ void reset();
+
+ void interrupt();
+
+ void interrupt_and_wait();
+
+ void interrupt_and_wait( system_time const& abs_time);
+
+ template< typename DurationType >
+ void interrupt_and_wait( DurationType const& rel_time)
+ { impl_->interrupt_and_wait( rel_time); }
+
+ bool interruption_requested();
+};
+}
+} }
+
+#endif // BOOST_TP_DETAIL_INTERRUPTER_H

Added: sandbox/async/boost/tp/detail/worker.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/worker.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,156 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_WORKER_H
+#define BOOST_TP_DETAIL_WORKER_H
+
+#include <cstddef>
+#include <utility>
+
+#include <boost/assert.hpp>
+#include <boost/function.hpp>
+#include <boost/interprocess/sync/interprocess_semaphore.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/detail/callable.hpp>
+#include <boost/tp/detail/interrupter.hpp>
+#include <boost/tp/detail/wsq.hpp>
+
+namespace boost {
+namespace tp {
+namespace detail
+{
+class worker
+{
+private:
+ static thread_specific_ptr< worker > tss_;
+
+ class impl : private noncopyable
+ {
+ private:
+ typedef std::pair< callable, interrupter > item;
+ shared_ptr< thread > thrd_;
+ wsq< item > wsq_;
+ interprocess::interprocess_semaphore shtdwn_sem_;
+ interprocess::interprocess_semaphore shtdwn_now_sem_;
+ bool shtdwn_;
+ std::size_t scns_;
+
+ public:
+ impl( function< void() > const&);
+
+ virtual ~impl() {}
+
+ const shared_ptr< thread > thrd() const;
+
+ const thread::id get_id() const;
+
+ void join() const;
+
+ void interrupt() const;
+
+ void put( callable const&, interrupter const&);
+
+ bool try_take( callable &, interrupter &);
+
+ bool try_steal( callable &, interrupter &);
+
+ bool empty();
+
+ void signal_shutdown();
+
+ void signal_shutdown_now();
+
+ bool shutdown();
+
+ bool shutdown_now();
+
+ std::size_t scanns() const;
+
+ void increment_scanns();
+
+ void reset_scanns();
+
+ virtual void reschedule_until( function< bool() > const&) = 0;
+ };
+
+ template< typename Pool >
+ class impl_pool : public impl
+ {
+ private:
+ Pool & p_;
+
+ public:
+ impl_pool( Pool & p, function< void() > const& fn)
+ : impl( fn), p_( p)
+ {}
+
+ void reschedule_until( function< bool() > const& pred)
+ { p_.reschedule_until( pred); }
+
+ Pool & get_pool() const
+ { return p_; }
+ };
+
+ shared_ptr< impl > impl_;
+
+public:
+ template< typename Pool >
+ worker(
+ Pool & pool,
+ function< void() > const& fn)
+ : impl_( new impl_pool< Pool >( pool, fn) )
+ {}
+
+ const shared_ptr< thread > thrd() const;
+
+ const thread::id get_id() const;
+
+ void join() const;
+
+ void interrupt() const;
+
+ void put( callable const&, interrupter const&);
+
+ bool try_take( callable &, interrupter &);
+
+ bool try_steal( callable &, interrupter &);
+
+ bool empty() const;
+
+ void signal_shutdown();
+
+ void signal_shutdown_now();
+
+ bool shutdown();
+
+ bool shutdown_now();
+
+ std::size_t scanns() const;
+
+ void increment_scanns();
+
+ void reset_scanns();
+
+ void reschedule_until( function< bool() > const&);
+
+ template< typename Pool >
+ Pool & get_thread_pool() const
+ {
+ impl_pool< Pool > * p( dynamic_cast< impl_pool< Pool > * >( impl_.get() ) );
+ BOOST_ASSERT( p);
+ return p->get_pool();
+ }
+
+ static worker * tss_get();
+
+ static void tss_reset( worker * w);
+};
+
+} } }
+
+#endif // BOOST_TP_DETAIL_WORKER_H
+

Added: sandbox/async/boost/tp/detail/wsq.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/detail/wsq.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,170 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_DETAIL_WSQ_H
+#define BOOST_TP_DETAIL_WSQ_H
+
+#include <utility>
+
+#include <boost/assert.hpp>
+#include <boost/interprocess/detail/atomic.hpp>
+#include <boost/foreach.hpp>
+#include <boost/function.hpp>
+#include <boost/shared_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/detail/interrupter.hpp>
+
+namespace boost { namespace tp {
+namespace detail
+{
+template< typename T >
+class wsq
+: private noncopyable
+{
+private:
+ class impl
+ {
+ private:
+ const int initial_size_;
+ shared_array< T > array_;
+ int capacity_;
+ int mask_;
+ volatile uint32_t head_idx_;
+ volatile uint32_t tail_idx_;
+ recursive_mutex mtx_;
+
+ public:
+ impl()
+ :
+ initial_size_( 32),
+ array_( new T[ initial_size_]),
+ capacity_( initial_size_),
+ mask_( initial_size_ - 1),
+ head_idx_( 0),
+ tail_idx_( 0),
+ mtx_()
+ {}
+
+ bool empty() const
+ { return head_idx_ >= tail_idx_; }
+
+ std::size_t size() const
+ { return tail_idx_ - head_idx_; }
+
+ void put( T const& t)
+ {
+ uint32_t tail( tail_idx_);
+ if ( tail <= head_idx_ + mask_)
+ {
+ array_[tail & mask_] = t;
+ tail_idx_ = tail + 1;
+ }
+ else
+ {
+ unique_lock< recursive_mutex > lk( mtx_);
+ uint32_t head( head_idx_);
+ int count( size() );
+
+ if ( count >= mask_)
+ {
+ capacity_ <<= 1;
+ shared_array< T > array( new T[capacity_]);
+ for ( int i( 0); i != count; ++i)
+ array[i] = array_[(i + head) & mask_];
+ array_.swap( array);
+ head_idx_ = 0;
+ tail_idx_ = tail = count;
+ mask_ = (mask_ << 1) | 1;
+ }
+ array_[tail & mask_] = t;
+ tail_idx_ = tail + 1;
+ }
+ }
+
+ bool try_take( T & t)
+ {
+ uint32_t tail( tail_idx_);
+ if ( tail == 0)
+ return false;
+ tail -= 1;
+ interprocess::detail::atomic_write32( & tail_idx_, tail);
+ if ( head_idx_ <= tail)
+ {
+ t = array_[tail & mask_];
+ return true;
+ }
+ else
+ {
+ unique_lock< recursive_mutex > lk( mtx_);
+ if ( head_idx_ <= tail)
+ {
+ t = array_[tail & mask_];
+ return true;
+ }
+ else
+ {
+ tail_idx_ = tail + 1;
+ return false;
+ }
+ }
+ }
+
+ bool try_steal( T & t)
+ {
+ recursive_mutex::scoped_try_lock lk( mtx_);
+ if ( lk.owns_lock() )
+ {
+ uint32_t head( head_idx_);
+ interprocess::detail::atomic_write32( & head_idx_, head + 1);
+ if ( head < tail_idx_)
+ {
+ t = array_[head & mask_];
+ return true;
+ }
+ else
+ {
+ head_idx_ = head;
+ return false;
+ }
+ }
+ return false;
+ }
+ };
+
+ shared_ptr< impl > impl_;
+
+public:
+ wsq()
+ : impl_( new impl() )
+ {}
+
+ bool empty() const
+ { return impl_->empty(); }
+
+ std::size_t size() const
+ { return impl_->size(); }
+
+ void put( T const& t)
+ { impl_->put( t); }
+
+ bool try_take( T & t)
+ { return impl_->try_take( t); }
+
+ bool try_steal( T & t)
+ { return impl_->try_steal( t); }
+
+ void swap( wsq & queue)
+ {
+ if ( this == & queue) return;
+ impl_.swap( queue.impl_);
+ }
+};
+} } }
+
+#endif // BOOST_TP_DETAIL_WSQ_H
+

Added: sandbox/async/boost/tp/exceptions.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/exceptions.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,59 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_EXCEPTIONS_H
+#define BOOST_TP_EXCEPTIONS_H
+
+#include <stdexcept>
+#include <string>
+
+namespace boost { namespace tp
+{
+class invalid_poolsize
+: public std::invalid_argument
+{
+public:
+ invalid_poolsize( std::string const& msg)
+ : std::invalid_argument( msg)
+ {}
+};
+
+class invalid_scanns
+: public std::invalid_argument
+{
+public:
+ invalid_scanns( std::string const& msg)
+ : std::invalid_argument( msg)
+ {}
+};
+
+class invalid_timeduration
+: public std::invalid_argument
+{
+public:
+ invalid_timeduration( std::string const& msg)
+ : std::invalid_argument( msg)
+ {}
+};
+
+class invalid_watermark
+: public std::invalid_argument
+{
+public:
+ invalid_watermark( std::string const& msg)
+ : std::invalid_argument( msg)
+ {}
+};
+
+class task_rejected
+: public std::runtime_error
+{
+public:
+ task_rejected( std::string const& msg)
+ : std::runtime_error( msg)
+ {}
+};
+} }
+
+#endif // BOOST_TP_EXCEPTIONS_H

Added: sandbox/async/boost/tp/fifo.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/fifo.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,92 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_FIFO_H
+#define BOOST_TP_FIFO_H
+
+#include <cstddef>
+#include <list>
+
+#include <boost/assert.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+
+#include <boost/tp/detail/info.hpp>
+#include <boost/tp/detail/interrupter.hpp>
+
+namespace boost { namespace tp
+{
+struct fifo
+{
+ typedef detail::has_no_priority priority_tag_type;
+
+ template< typename Callable >
+ class impl
+ {
+ private:
+ typedef Callable callable;
+
+ public:
+ class item
+ {
+ private:
+ callable ca_;
+ detail::interrupter intr_;
+
+ public:
+ item(
+ callable const& ca,
+ detail::interrupter const& intr)
+ : ca_( ca), intr_( intr)
+ { BOOST_ASSERT( ! ca_.empty() ); }
+
+ const callable ca() const
+ { return ca_; }
+
+ const detail::interrupter intr() const
+ { return intr_; }
+ };
+
+ typedef typename std::list< item >::iterator iterator;
+ typedef typename std::list< item >::const_iterator const_iterator;
+
+ private:
+ std::list< item > lst_;
+
+ public:
+ void push( item const& itm)
+ { lst_.push_back( itm); }
+
+ const item pop()
+ {
+ item itm( lst_.front() );
+ lst_.pop_front();
+ return itm;
+ }
+
+ std::size_t size() const
+ { return lst_.size(); }
+
+ bool empty() const
+ { return lst_.empty(); }
+
+ void clear()
+ { lst_.clear(); }
+
+ const iterator begin()
+ { return lst_.begin(); }
+
+ const const_iterator begin() const
+ { return lst_.begin(); }
+
+ const iterator end()
+ { return lst_.end(); }
+
+ const const_iterator end() const
+ { return lst_.end(); }
+ };
+};
+} }
+
+#endif // BOOST_TP_FIFO_H

Added: sandbox/async/boost/tp/info.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/info.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,34 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_INFO_H
+#define BOOST_TP_INFO_H
+
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/tp/detail/info.hpp>
+
+namespace boost { namespace tp
+{
+template< typename Pool >
+struct has_priority
+:
+public mpl::bool_<
+ is_same<
+ detail::has_priority,
+ typename Pool::scheduler_type::priority_tag_type
+ >::value
+>
+{};
+
+template< typename Pool >
+struct priority_type
+{
+ typedef typename Pool::scheduler_type::attribute_type type;
+};
+} }
+
+#endif // BOOST_TP_INFO_H
+

Added: sandbox/async/boost/tp/lifo.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/lifo.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,92 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_LIFO_H
+#define BOOST_TP_LIFO_H
+
+#include <cstddef>
+#include <list>
+
+#include <boost/assert.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+
+#include <boost/tp/detail/info.hpp>
+#include <boost/tp/detail/interrupter.hpp>
+
+namespace boost { namespace tp
+{
+struct lifo
+{
+ typedef detail::has_no_priority priority_tag_type;
+
+ template< typename Callable >
+ class impl
+ {
+ private:
+ typedef Callable callable;
+
+ public:
+ class item
+ {
+ private:
+ callable ca_;
+ detail::interrupter intr_;
+
+ public:
+ item(
+ callable const& ca,
+ detail::interrupter const& intr)
+ : ca_( ca), intr_( intr)
+ { BOOST_ASSERT( ! ca_.empty() ); }
+
+ const callable ca() const
+ { return ca_; }
+
+ const detail::interrupter intr() const
+ { return intr_; }
+ };
+
+ typedef typename std::list< item >::iterator iterator;
+ typedef typename std::list< item >::const_iterator const_iterator;
+
+ private:
+ std::list< item > lst_;
+
+ public:
+ void push( item const& itm)
+ { lst_.push_front( itm); }
+
+ const item pop()
+ {
+ item itm( lst_.front() );
+ lst_.pop_front();
+ return itm;
+ }
+
+ std::size_t size() const
+ { return lst_.size(); }
+
+ bool empty() const
+ { return lst_.empty(); }
+
+ void clear()
+ { lst_.clear(); }
+
+ const iterator begin()
+ { return lst_.begin(); }
+
+ const const_iterator begin() const
+ { return lst_.begin(); }
+
+ const iterator end()
+ { return lst_.end(); }
+
+ const const_iterator end() const
+ { return lst_.end(); }
+ };
+};
+} }
+
+#endif // BOOST_TP_LIFO_H

Added: sandbox/async/boost/tp/pool.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/pool.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,618 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_POOL_H
+#define BOOST_TP_POOL_H
+
+#include <cstddef>
+#include <list>
+#include <utility>
+#include <vector>
+
+#include <boost/future.hpp>
+
+#include <boost/assert.hpp>
+#include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+#include <boost/function.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/mem_fun.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/random.hpp>
+#include <boost/ref.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread.hpp>
+#include <boost/utility.hpp>
+#include <boost/utility/result_of.hpp>
+
+#include <boost/tp/detail/callable.hpp>
+#include <boost/tp/detail/guard.hpp>
+#include <boost/tp/detail/interrupter.hpp>
+#ifdef BOOST_BIND_WORKER_TO_PROCESSORS
+#include <boost/tp/detail/bind_processor.hpp>
+#endif
+#include <boost/tp/detail/worker.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/scanns.hpp>
+#include <boost/tp/task.hpp>
+#include <boost/tp/watermark.hpp>
+
+namespace boost {
+namespace this_task
+{
+template< typename Pred >
+void reschedule_until( Pred const& pred)
+{
+ tp::detail::worker * w( tp::detail::worker::tss_get() );
+ BOOST_ASSERT( w);
+ w->reschedule_until( pred);
+}
+
+template< typename Pool >
+Pool & get_thread_pool()
+{
+ tp::detail::worker * w( tp::detail::worker::tss_get() );
+ BOOST_ASSERT( w);
+ return w->get_thread_pool< Pool >();
+}
+
+inline
+bool is_worker()
+{ return tp::detail::worker::tss_get() != 0; }
+
+inline
+thread::id worker_id()
+{
+ tp::detail::worker * w( tp::detail::worker::tss_get() );
+ BOOST_ASSERT( w);
+ return w->get_id();
+}
+}
+
+namespace tp
+{
+template< typename Channel >
+class pool : private noncopyable
+{
+private:
+ template< typename Pred >
+ friend void this_task::reschedule_until( Pred const&);
+
+ template< typename Pool >
+ friend Pool & this_task::get_thread_pool();
+
+ friend class detail::worker;
+
+ typedef Channel channel;
+ typedef typename channel::item channel_item;
+
+ enum state
+ {
+ active_state,
+ terminateing_state,
+ terminated_state
+ };
+
+ struct id_idx_tag {};
+ struct rnd_idx_tag {};
+
+ typedef multi_index::multi_index_container<
+ detail::worker,
+ multi_index::indexed_by<
+ multi_index::ordered_unique<
+ multi_index::tag< id_idx_tag >,
+ multi_index::const_mem_fun<
+ detail::worker,
+ const thread::id,
+ & detail::worker::get_id
+ >
+ >,
+ multi_index::random_access< multi_index::tag< rnd_idx_tag > >
+ >
+ > worker_list;
+
+ typedef typename worker_list::template index<
+ id_idx_tag >::type id_idx;
+ typedef typename worker_list::template index<
+ rnd_idx_tag >::type rnd_idx;
+
+ class random_idx
+ {
+ private:
+ rand48 rng_;
+ uniform_int<> six_;
+ variate_generator< rand48 &, uniform_int<> > die_;
+
+ public:
+ random_idx( std::size_t size)
+ :
+ rng_(),
+ six_( 0, size - 1),
+ die_( rng_, six_)
+ {}
+
+ std::size_t operator()()
+ { return die_(); }
+ };
+
+ static thread_specific_ptr< random_idx > tss_rnd_idx_;
+
+ worker_list worker_;
+ shared_mutex mtx_worker_;
+ state state_;
+ shared_mutex mtx_state_;
+ channel channel_;
+ posix_time::time_duration asleep_;
+ scanns scns_;
+ volatile uint32_t active_worker_;
+ volatile uint32_t idle_worker_;
+ volatile uint32_t running_worker_;
+
+ void execute_(
+ detail::callable & ca,
+ detail::interrupter & intr,
+ shared_ptr< thread > const& thrd)
+ {
+ BOOST_ASSERT( ! ca.empty() );
+ detail::guard grd( active_worker_);
+ shared_ptr< void > ig(
+ static_cast< void * >( 0),
+ boost::bind(
+ & detail::interrupter::reset,
+ intr) );
+ intr.set( thrd);
+ ca();
+ ca.clear();
+ BOOST_ASSERT( ca.empty() );
+ }
+
+ void next_callable_( detail::worker & w, detail::callable & ca, detail::interrupter & intr)
+ {
+ rnd_idx & ridx( worker_.get< rnd_idx_tag >() );
+ if ( ! w.try_take( ca, intr) )
+ {
+ if ( ! channel_.try_take( ca, intr) )
+ {
+ std::size_t idx( ( * tss_rnd_idx_)() );
+ for ( std::size_t j( 0); j < worker_.size(); ++j)
+ {
+ detail::worker other( ridx[idx]);
+ if ( this_thread::get_id() == other.get_id() ) continue;
+ if ( ++idx >= worker_.size() ) idx = 0;
+ if ( other.try_steal( ca, intr) ) break;
+ }
+
+ if ( ca.empty() )
+ {
+ detail::guard grd( idle_worker_);
+ if ( shutdown_( w) ) return;
+ w.increment_scanns();
+ if ( w.scanns() >= scns_)
+ {
+ if ( size_() == idle_worker_)
+ channel_.take( ca, intr, asleep_);
+ else
+ this_thread::sleep( asleep_);
+ w.reset_scanns();
+ }
+ else
+ this_thread::yield();
+ }
+ }
+ }
+ }
+
+ void reschedule_until_( function< bool() > const& pred)
+ {
+ detail::worker * w( detail::worker::tss_get() );
+ BOOST_ASSERT( w);
+ BOOST_ASSERT( w->get_id() == this_thread::get_id() );
+ shared_ptr< thread > thrd( w->thrd() );
+ BOOST_ASSERT( thrd);
+ detail::interrupter intr;
+ detail::callable ca;
+ while ( ! pred() )
+ {
+ next_callable_( * w, ca, intr);
+ if( ! ca.empty() )
+ {
+ execute_( ca, intr, thrd);
+ w->reset_scanns();
+ }
+ }
+ }
+
+ void entry_()
+ {
+ shared_lock< shared_mutex > lk( mtx_worker_);
+ id_idx & iidx( worker_.get< id_idx_tag >() );
+ typename id_idx::iterator i( iidx.find( this_thread::get_id() ) );
+ lk.unlock();
+ BOOST_ASSERT( i != iidx.end() );
+ detail::worker::tss_reset( new detail::worker( * i) );
+
+ detail::worker * w( detail::worker::tss_get() );
+ BOOST_ASSERT( w);
+ BOOST_ASSERT( w->get_id() == this_thread::get_id() );
+ shared_ptr< thread > thrd( w->thrd() );
+ BOOST_ASSERT( thrd);
+ detail::callable ca;
+ detail::interrupter intr;
+
+ tss_rnd_idx_.reset( new random_idx( worker_.size() ) );
+
+ detail::guard grd( running_worker_);
+
+ while ( ! shutdown_( * w) )
+ {
+ next_callable_( * w, ca, intr);
+ if( ! ca.empty() )
+ {
+ execute_( ca, intr, thrd);
+ w->reset_scanns();
+ }
+ }
+ }
+
+ void create_worker_()
+ {
+ BOOST_ASSERT( ! terminateing_() && ! terminated_() );
+ worker_.insert(
+ detail::worker(
+ * this,
+ boost::bind(
+ & pool::entry_,
+ this) ) );
+ }
+
+#ifdef BOOST_BIND_WORKER_TO_PROCESSORS
+ void entry_( std::size_t n)
+ {
+ this_thread::bind_to_processor( n);
+ entry_();
+ }
+
+ void create_worker_( std::size_t n)
+ {
+ BOOST_ASSERT( ! terminateing_() && ! terminated_() );
+ worker_.insert(
+ detail::worker(
+ * this,
+ boost::bind(
+ & pool::entry_,
+ this,
+ n) ) );
+ }
+#endif
+
+ std::size_t active_() const
+ { return active_worker_; }
+
+ std::size_t idle_() const
+ { return size_() - active_(); }
+
+ std::size_t size_() const
+ { return worker_.size(); }
+
+ bool terminated_() const
+ { return state_ == terminated_state; }
+
+ bool terminateing_() const
+ { return state_ == terminateing_state; }
+
+ bool shutdown_( detail::worker & w)
+ {
+ if ( w.shutdown() && channel_.empty() )
+ return true;
+ else if ( w.shutdown_now() )
+ return true;
+ return false;
+ }
+
+public:
+ explicit pool(
+ poolsize const& psize,
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) )
+ :
+ worker_(),
+ mtx_worker_(),
+ state_( active_state),
+ mtx_state_(),
+ channel_(),
+ asleep_( asleep),
+ scns_( scns),
+ active_worker_( 0),
+ idle_worker_( 0),
+ running_worker_( 0)
+ {
+ if ( asleep_.is_special() || asleep_.is_negative() )
+ throw invalid_timeduration("argument asleep is not valid");
+ channel_.activate();
+ unique_lock< shared_mutex > lk( mtx_worker_);
+ for ( std::size_t i( 0); i < psize; ++i)
+ create_worker_();
+ lk.unlock();
+ }
+
+ explicit pool(
+ poolsize const& psize,
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::microseconds( 100),
+ scanns const& scns = scanns( 20) )
+ :
+ worker_(),
+ mtx_worker_(),
+ state_( active_state),
+ mtx_state_(),
+ channel_(
+ hwm,
+ lwm),
+ asleep_( asleep),
+ scns_( scns),
+ active_worker_( 0),
+ idle_worker_( 0),
+ running_worker_( 0)
+ {
+ if ( asleep_.is_special() || asleep_.is_negative() )
+ throw invalid_timeduration("argument asleep is not valid");
+ channel_.activate();
+ unique_lock< shared_mutex > lk( mtx_worker_);
+ for ( std::size_t i( 0); i < psize; ++i)
+ create_worker_();
+ lk.unlock();
+ }
+
+#ifdef BOOST_BIND_WORKER_TO_PROCESSORS
+ explicit pool(
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) )
+ :
+ worker_(),
+ mtx_worker_(),
+ state_( active_state),
+ mtx_state_(),
+ channel_(),
+ asleep_( asleep),
+ scns_( scns),
+ active_worker_( 0),
+ idle_worker_( 0),
+ running_worker_( 0)
+ {
+ if ( asleep_.is_special() || asleep_.is_negative() )
+ throw invalid_timeduration("argument asleep is not valid");
+ std::size_t psize( thread::hardware_concurrency() );
+ BOOST_ASSERT( psize > 0);
+ channel_.activate();
+ unique_lock< shared_mutex > lk( mtx_worker_);
+ for ( std::size_t i( 0); i < psize; ++i)
+ create_worker_( i);
+ lk.unlock();
+ }
+
+ explicit pool(
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::microseconds( 100),
+ scanns const& scns = scanns( 20) )
+ :
+ worker_(),
+ mtx_worker_(),
+ state_( active_state),
+ mtx_state_(),
+ channel_(
+ hwm,
+ lwm),
+ asleep_( asleep),
+ scns_( scns),
+ active_worker_( 0),
+ idle_worker_( 0),
+ running_worker_( 0)
+ {
+ if ( asleep_.is_special() || asleep_.is_negative() )
+ throw invalid_timeduration("argument asleep is not valid");
+ std::size_t psize( thread::hardware_concurrency() );
+ BOOST_ASSERT( psize > 0);
+ channel_.activate();
+ unique_lock< shared_mutex > lk( mtx_worker_);
+ for ( std::size_t i( 0); i < psize; ++i)
+ create_worker_( i);
+ lk.unlock();
+ }
+#endif
+
+ ~pool()
+ { shutdown(); }
+
+ std::size_t active()
+ {
+ shared_lock< shared_mutex > lk( mtx_worker_);
+ return active_();
+ }
+
+ std::size_t idle()
+ {
+ shared_lock< shared_mutex > lk( mtx_worker_);
+ return idle_();
+ }
+
+ void shutdown()
+ {
+ unique_lock< shared_mutex > lk1( mtx_state_);
+ if ( terminateing_() || terminated_() ) return;
+ state_ = terminateing_state;
+ lk1.unlock();
+
+ channel_.deactivate();
+ shared_lock< shared_mutex > lk2( mtx_worker_);
+ BOOST_FOREACH( detail::worker w, worker_)
+ { w.signal_shutdown(); }
+ BOOST_FOREACH( detail::worker w, worker_)
+ { w.join(); }
+ lk2.unlock();
+
+ lk1.lock();
+ state_ = terminated_state;
+ }
+
+ const std::vector< detail::callable > shutdown_now()
+ {
+ unique_lock< shared_mutex > lk1( mtx_state_);
+ if ( terminateing_() || terminated_() ) return std::vector< detail::callable >();
+ state_ = terminateing_state;
+ lk1.unlock();
+
+ channel_.deactivate_now();
+ shared_lock< shared_mutex > lk2( mtx_worker_);
+ BOOST_FOREACH( detail::worker w, worker_)
+ {
+ w.signal_shutdown_now();
+ w.interrupt();
+ }
+ BOOST_FOREACH( detail::worker w, worker_)
+ { w.join(); }
+ lk2.unlock();
+ std::vector< detail::callable > drain( channel_.drain() );
+
+ lk1.lock();
+ state_ = terminated_state;
+ lk1.unlock();
+
+ return drain;
+ }
+
+ std::size_t size()
+ {
+ shared_lock< shared_mutex > lk( mtx_worker_);
+ return size_();
+ }
+
+ bool terminated()
+ {
+ shared_lock< shared_mutex > lk( mtx_state_);
+ return terminated_();
+ }
+
+ bool terminateing()
+ {
+ shared_lock< shared_mutex > lk( mtx_state_);
+ return terminateing_();
+ }
+
+ void clear()
+ { channel_.clear(); }
+
+ bool empty()
+ { return channel_.empty(); }
+
+ std::size_t pending()
+ { return channel_.size(); }
+
+ std::size_t upper_bound()
+ { return channel_.upper_bound(); }
+
+ void upper_bound( high_watermark const& hwm)
+ { return channel_.upper_bound( hwm); }
+
+ std::size_t lower_bound()
+ { return channel_.lower_bound(); }
+
+ void lower_bound( low_watermark const lwm)
+ { return channel_.lower_bound( lwm); }
+
+ template< typename Act >
+ task< typename result_of< Act() >::type > submit( Act const& act)
+ {
+ typedef typename result_of< Act() >::type R;
+ detail::interrupter intr;
+ packaged_task< R > tsk( act);
+ shared_future< R > f( tsk.get_future() );
+ detail::worker * w( detail::worker::tss_get() );
+ if ( w)
+ {
+ function< bool() > wcb(
+ bind(
+ & shared_future< R >::is_ready,
+ f) );
+ tsk.set_wait_callback(
+ bind(
+ ( void ( pool::*)( function< bool() > const&) ) & pool::reschedule_until_,
+ this,
+ wcb) );
+ w->put( detail::callable( move( tsk) ), intr);
+ return task< R >( f, intr);
+ }
+ else
+ {
+ shared_lock< shared_mutex > lk( mtx_state_);
+ if ( terminated_() )
+ throw task_rejected("pool ist terminated");
+ if ( terminateing_() )
+ throw task_rejected("pool ist terminateing");
+
+ channel_item itm( detail::callable( move( tsk) ), intr);
+ channel_.put( itm);
+ return task< R >( f, intr);
+ }
+ }
+
+ template<
+ typename Act,
+ typename Attr
+ >
+ task< typename result_of< Act() >::type > submit(
+ Act const& act,
+ Attr const& attr)
+ {
+ typedef typename result_of< Act() >::type R;
+ detail::interrupter intr;
+ packaged_task< R > tsk( act);
+ shared_future< R > f( tsk.get_future() );
+ detail::worker * w( detail::worker::tss_get() );
+ if ( w)
+ {
+ function< bool() > wcb(
+ bind(
+ & shared_future< R >::is_ready,
+ f) );
+ tsk.set_wait_callback(
+ bind(
+ ( void ( pool::*)( function< bool() > const&) ) & pool::reschedule_until_,
+ this,
+ wcb) );
+ w->put( detail::callable( move( tsk) ), intr);
+ return task< R >( f, intr);
+ }
+ else
+ {
+ shared_lock< shared_mutex > lk( mtx_state_);
+ if ( terminated_() )
+ throw task_rejected("pool ist terminated");
+ if ( terminateing_() )
+ throw task_rejected("pool ist terminateing");
+
+ channel_item itm( detail::callable( move( tsk) ), attr, intr);
+ channel_.put( itm);
+ return task< R >( f, intr);
+ }
+ }
+ template< typename Pred >
+ void reschedule_until( Pred const& pred)
+ {
+ reschedule_until_(pred);
+ }
+};
+
+template< typename Channel >
+thread_specific_ptr< typename pool< Channel >::random_idx >
+pool< Channel >::tss_rnd_idx_;
+
+}}
+
+#endif // BOOST_TP_POOL_H
+

Added: sandbox/async/boost/tp/poolsize.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/poolsize.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,26 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_POOLSIZE_H
+#define BOOST_TP_POOLSIZE_H
+
+#include <cstddef>
+
+#include <boost/tp/exceptions.hpp>
+
+namespace boost { namespace tp
+{
+class poolsize
+{
+private:
+ std::size_t value_;
+
+public:
+ explicit poolsize( std::size_t value);
+
+ operator std::size_t () const;
+};
+} }
+
+#endif // BOOST_TP_POOLSIZE_H

Added: sandbox/async/boost/tp/priority.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/priority.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,130 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_PRIORITY_H
+#define BOOST_TP_PRIORITY_H
+
+#include <cstddef>
+#include <utility>
+
+#include <boost/assert.hpp>
+#include <boost/function.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/mem_fun.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+
+#include <boost/tp/detail/info.hpp>
+#include <boost/tp/detail/interrupter.hpp>
+
+namespace boost { namespace tp
+{
+template<
+ typename Attr,
+ typename Ord = std::less< Attr >
+>
+struct priority
+{
+ typedef Attr attribute_type;
+ typedef detail::has_priority priority_tag_type;
+
+ template< typename Callable >
+ class impl
+ {
+ private:
+ typedef Attr attribute;
+ typedef Callable callable;
+ typedef Ord ordering;
+
+ public:
+ class item
+ {
+ private:
+ callable ca_;
+ attribute attr_;
+ detail::interrupter intr_;
+
+ public:
+ item(
+ callable const& ca,
+ attribute const& attr,
+ detail::interrupter const& intr)
+ : ca_( ca), attr_( attr), intr_( intr)
+ { BOOST_ASSERT( ! ca_.empty() ); }
+
+ const callable ca() const
+ { return ca_; }
+
+ const attribute attr() const
+ { return attr_; }
+
+ const detail::interrupter intr() const
+ { return intr_; }
+ };
+
+ private:
+ typedef multi_index::multi_index_container<
+ item,
+ multi_index::indexed_by<
+ multi_index::ordered_non_unique<
+ multi_index::const_mem_fun<
+ item,
+ const attribute,
+ & item::attr
+ >,
+ ordering
+ >
+ >
+ > list;
+ typedef typename list::template nth_index< 0 >::type index;
+
+ list lst_;
+ index & idx_;
+
+ public:
+ typedef typename list::iterator iterator;
+ typedef typename list::const_iterator const_iterator;
+
+ impl()
+ :
+ lst_(),
+ idx_( lst_.get< 0 >() )
+ {}
+
+ void push( item const& itm)
+ { idx_.insert( itm); }
+
+ const item pop()
+ {
+ iterator i( lst_.begin() );
+ BOOST_ASSERT( i != lst_.end() );
+ item itm( * i);
+ lst_.erase( i);
+ return itm;
+ }
+
+ std::size_t size() const
+ { return lst_.size(); }
+
+ bool empty() const
+ { return lst_.empty(); }
+
+ void clear()
+ { lst_.clear(); }
+
+ const iterator begin()
+ { return lst_.begin(); }
+
+ const const_iterator begin() const
+ { return lst_.begin(); }
+
+ const iterator end()
+ { return lst_.end(); }
+
+ const const_iterator end() const
+ { return lst_.end(); }
+ };
+};
+} }
+
+#endif // BOOST_TP_PRIORITY_H

Added: sandbox/async/boost/tp/scanns.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/scanns.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,27 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_SCANNS_H
+#define BOOST_TP_SCANNS_H
+
+#include <cstddef>
+
+#include <boost/tp/exceptions.hpp>
+
+namespace boost { namespace tp
+{
+
+class scanns
+{
+private:
+ std::size_t value_;
+
+public:
+ explicit scanns( std::size_t value);
+
+ operator std::size_t () const;
+};
+} }
+
+#endif // BOOST_TP_SCANNS_H

Added: sandbox/async/boost/tp/smart.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/smart.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,174 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_SMART_H
+#define BOOST_TP_SMART_H
+
+#include <cstddef>
+
+#include <boost/assert.hpp>
+#include <boost/function.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/mem_fun.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+
+#include <boost/tp/detail/info.hpp>
+#include <boost/tp/detail/interrupter.hpp>
+
+namespace boost { namespace tp
+{
+template<
+ typename Attr,
+ typename Ord,
+ typename Enq,
+ typename Deq
+>
+struct smart
+{
+ typedef Attr attribute_type;
+ typedef detail::has_priority priority_tag_type;
+
+ template< typename Callable >
+ class impl
+ {
+ private:
+ typedef Attr attribute;
+ typedef Callable callable;
+ typedef Deq dequeue_op;
+ typedef Enq enqueue_op;
+ typedef Ord ordering;
+
+ public:
+ class item
+ {
+ private:
+ callable ca_;
+ attribute attr_;
+ detail::interrupter intr_;
+
+ public:
+ item()
+ : ca_(), attr_(), intr_()
+ {}
+
+ item(
+ callable const& ca,
+ attribute const& attr,
+ detail::interrupter const& intr)
+ : ca_( ca), attr_( attr), intr_( intr)
+ { BOOST_ASSERT( ! ca_.empty() ); }
+
+ const callable ca() const
+ { return ca_; }
+
+ const attribute attr() const
+ { return attr_; }
+
+ const detail::interrupter intr() const
+ { return intr_; }
+ };
+
+ private:
+ typedef multi_index::multi_index_container<
+ item,
+ multi_index::indexed_by<
+ multi_index::ordered_non_unique<
+ multi_index::const_mem_fun<
+ item,
+ const attribute,
+ & item::attr
+ >,
+ ordering
+ >
+ >
+ > list;
+ typedef typename list::template nth_index< 0 >::type index;
+
+ list lst_;
+ index & idx_;
+ enqueue_op enq_op_;
+ dequeue_op deq_op_;
+
+ public:
+ typedef typename index::iterator iterator;
+ typedef typename index::const_iterator const_iterator;
+
+ impl(
+ enqueue_op const& enq_op = enqueue_op(),
+ dequeue_op const& deq_op = dequeue_op() )
+ :
+ lst_(),
+ idx_( lst_.get< 0 >() ),
+ enq_op_( enq_op),
+ deq_op_( deq_op)
+ {}
+
+ void push( item const& itm)
+ { enq_op_( idx_, itm); }
+
+ const item pop()
+ {
+ item itm;
+ deq_op_( idx_, itm);
+ return itm;
+ }
+
+ std::size_t size() const
+ { return lst_.size(); }
+
+ bool empty() const
+ { return lst_.empty(); }
+
+ void clear()
+ { lst_.clear(); }
+
+ const iterator begin()
+ { return lst_.begin(); }
+
+ const const_iterator begin() const
+ { return lst_.begin(); }
+
+ const iterator end()
+ { return lst_.end(); }
+
+ const const_iterator end() const
+ { return lst_.end(); }
+ };
+};
+
+struct replace_oldest
+{
+ template<
+ typename Index,
+ typename Item
+ >
+ void operator()( Index & idx, Item const& itm)
+ {
+ typedef typename Index::iterator iterator;
+ iterator i( idx.find( itm.attr() ) );
+ if ( i == idx.end() )
+ idx.insert( itm);
+ else
+ idx.replace( i, itm);
+ }
+};
+
+struct take_oldest
+{
+ template<
+ typename Index,
+ typename Item
+ >
+ void operator()( Index & idx, Item & itm)
+ {
+ typedef typename Index::iterator iterator;
+ iterator i( idx.begin() );
+ BOOST_ASSERT( i != idx.end() );
+ itm = * i;
+ idx.erase( i);
+ }
+};
+} }
+
+#endif // BOOST_TP_SMART_H

Added: sandbox/async/boost/tp/task.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/task.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,96 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_TASK_H
+#define BOOST_TP_TASK_H
+
+#include <boost/future.hpp>
+#include <boost/thread/thread_time.hpp>
+
+#include <boost/tp/detail/interrupter.hpp>
+
+namespace boost { namespace tp
+{
+template< typename R >
+class task
+{
+private:
+ shared_future< R > fut_;
+ detail::interrupter intr_;
+
+public:
+ task()
+ : fut_(), intr_()
+ {}
+
+ task(
+ shared_future< R > const& fut,
+ detail::interrupter const& intr)
+ :
+ fut_( fut),
+ intr_( intr)
+ {}
+
+ void interrupt()
+ { intr_.interrupt(); }
+
+ void interrupt_and_wait()
+ { intr_.interrupt_and_wait(); }
+
+ void interrupt_and_wait( system_time const& abs_time)
+ { intr_.interrupt_and_wait( abs_time); }
+
+ template< typename Duration >
+ void interrupt_and_wait( Duration const& rel_time)
+ { intr_.interrupt_and_wait( rel_time); }
+
+ bool interruption_requested()
+ { return intr_.interruption_requested(); }
+
+ shared_future< R > result()
+ { return fut_; }
+};
+
+template<>
+class task< void >
+{
+private:
+ shared_future< void > fut_;
+ detail::interrupter intr_;
+
+public:
+ task()
+ : fut_(), intr_()
+ {}
+ task(
+ shared_future< void > const& fut,
+ detail::interrupter const& intr)
+ :
+ fut_( fut),
+ intr_( intr)
+ {}
+
+ void interrupt()
+ { intr_.interrupt(); }
+
+ void interrupt_and_wait()
+ { intr_.interrupt_and_wait(); }
+
+ void interrupt_and_wait( system_time const& abs_time)
+ { intr_.interrupt_and_wait( abs_time); }
+
+ template< typename Duration >
+ void interrupt_and_wait( Duration const& rel_time)
+ { intr_.interrupt_and_wait( rel_time); }
+
+ bool interruption_requested()
+ { return intr_.interruption_requested(); }
+
+ shared_future< void > result()
+ { return fut_; }
+};
+
+} }
+
+#endif // BOOST_TP_TASK_H

Added: sandbox/async/boost/tp/unbounded_channel.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/unbounded_channel.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,294 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_UNBOUNDED_CHANNEL_H
+#define BOOST_TP_UNBOUNDED_CHANNEL_H
+
+#include <cstddef>
+#include <vector>
+
+#include <boost/assert.hpp>
+#include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+#include <boost/function.hpp>
+#include <boost/ref.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+#include <boost/tp/detail/callable.hpp>
+#include <boost/tp/detail/interrupter.hpp>
+#include <boost/tp/exceptions.hpp>
+
+namespace boost { namespace tp
+{
+template< typename SchedulingPolicy >
+class unbounded_channel
+{
+private:
+ typedef SchedulingPolicy scheduling_policy;
+ typedef typename scheduling_policy::template impl<
+ detail::callable
+ > queue;
+
+public:
+ typedef typename queue::item item;
+ typedef scheduling_policy scheduler_type;
+
+private:
+ enum channel_state
+ {
+ channel_active,
+ channel_deactive,
+ channel_deactive_now
+ };
+
+ channel_state state_;
+ queue queue_;
+ shared_mutex mtx_;
+ condition not_empty_cond_;
+
+ bool active_() const
+ { return state_ == channel_active; }
+
+ bool deactive_() const
+ { return state_ == channel_deactive; }
+
+ bool deactive_now_() const
+ { return state_ == channel_deactive_now; }
+
+ void activate_()
+ { state_ = channel_active; }
+
+ void clear_()
+ {
+ BOOST_ASSERT( ! active_() );
+ queue_.clear();
+ BOOST_ASSERT( empty_() );
+ }
+
+ void deactivate_()
+ {
+ if ( active_() )
+ {
+ state_ = channel_deactive;
+ not_empty_cond_.notify_all();
+ }
+
+ BOOST_ASSERT( deactive_() );
+ }
+
+ void deactivate_now_()
+ {
+ if ( active_() )
+ {
+ state_ = channel_deactive_now;
+ not_empty_cond_.notify_all();
+ }
+
+ BOOST_ASSERT( deactive_now_() );
+ }
+
+ const std::vector< detail::callable > drain_()
+ {
+ BOOST_ASSERT( deactive_now_() );
+ std::vector< detail::callable > unprocessed;
+ unprocessed.reserve( queue_.size() );
+ BOOST_FOREACH( item itm, queue_)
+ { unprocessed.push_back( itm.ca() ); }
+ clear_();
+ BOOST_ASSERT( empty_() );
+ return unprocessed;
+ }
+
+ bool empty_() const
+ { return queue_.empty(); }
+
+ std::size_t size_() const
+ { return queue_.size(); }
+
+ void put_(
+ item const& itm,
+ unique_lock< shared_mutex > & lk)
+ {
+ queue_.push( itm);
+ not_empty_cond_.notify_one();
+ }
+
+ bool take_(
+ detail::callable & ca,
+ detail::interrupter & intr,
+ unique_lock< shared_mutex > & lk)
+ {
+ if ( deactive_now_() || ( deactive_() && empty_() ) )
+ return false;
+ try
+ {
+ not_empty_cond_.wait(
+ lk,
+ bind(
+ & unbounded_channel::consumers_activate_,
+ this) );
+ }
+ catch ( thread_interrupted const& e)
+ { return false; }
+ if ( deactive_now_() || ( deactive_() && empty_() ) )
+ return false;
+ item itm( queue_.pop() );
+ ca = itm.ca();
+ intr = itm.intr();
+ return ! ca.empty();
+ }
+
+ template< typename Duration >
+ bool take_(
+ detail::callable & ca,
+ detail::interrupter & intr,
+ Duration const& rel_time,
+ unique_lock< shared_mutex > & lk)
+ {
+ if ( deactive_now_() || ( deactive_() && empty_() ) )
+ return false;
+ try
+ {
+ if ( ! not_empty_cond_.timed_wait(
+ lk,
+ rel_time,
+ bind(
+ & unbounded_channel::consumers_activate_,
+ this) ) )
+ return false;
+ }
+ catch ( thread_interrupted const& e)
+ { return false; }
+ if ( deactive_now_() || ( deactive_() && empty_() ) )
+ return false;
+ item itm( queue_.pop() );
+ ca = itm.ca();
+ intr = itm.intr();
+ return ! ca.empty();
+ }
+
+ bool try_take_(
+ detail::callable & ca,
+ detail::interrupter & intr)
+ {
+ if ( deactive_now_() || empty_() )
+ return false;
+ item itm( queue_.pop() );
+ ca = itm.ca();
+ intr = itm.intr();
+ return ! ca.empty();
+ }
+
+ bool consumers_activate_() const
+ { return ! active_() || ! empty_(); }
+
+public:
+ unbounded_channel()
+ :
+ state_( channel_active),
+ queue_(),
+ mtx_(),
+ not_empty_cond_()
+ {}
+
+ bool active()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return active_();
+ }
+
+ void activate()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ activate_();
+ }
+
+ void clear()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ clear_();
+ }
+
+ bool deactive()
+ { return ! active(); }
+
+ void deactivate()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ deactivate_();
+ }
+
+ void deactivate_now()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ deactivate_now_();
+ }
+
+ const std::vector< detail::callable > drain()
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ return drain_();
+ }
+
+ bool empty()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return empty_();
+ }
+
+ bool full()
+ { return false; }
+
+ std::size_t size()
+ {
+ shared_lock< shared_mutex > lk( mtx_);
+ return size_();
+ }
+
+ void put( item const& itm)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ put_( itm, lk);
+ }
+
+ template< typename Duration >
+ void put(
+ item const& itm,
+ Duration const&)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ put_( itm, lk);
+ }
+
+ bool take(
+ detail::callable & ca,
+ detail::interrupter & intr)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ return take_( ca, intr, lk);
+ }
+
+ template< typename Duration >
+ bool take(
+ detail::callable & ca,
+ detail::interrupter & intr,
+ Duration const& rel_time)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ return take_( ca, intr, rel_time, lk);
+ }
+
+ bool try_take(
+ detail::callable & ca,
+ detail::interrupter & intr)
+ {
+ unique_lock< shared_mutex > lk( mtx_);
+ return try_take_( ca, intr);
+ }
+};
+} }
+
+#endif // BOOST_TP_UNBOUNDED_CHANNEL_H

Added: sandbox/async/boost/tp/watermark.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/tp/watermark.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,37 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_WATER_MARK_H
+#define BOOST_TP_WATER_MARK_H
+
+#include <cstddef>
+
+#include <boost/tp/exceptions.hpp>
+
+namespace boost { namespace tp
+{
+class high_watermark
+{
+private:
+ std::size_t value_;
+
+public:
+ explicit high_watermark( std::size_t value);
+
+ operator std::size_t () const;
+};
+
+class low_watermark
+{
+private:
+ std::size_t value_;
+
+public:
+ explicit low_watermark( std::size_t value);
+
+ operator std::size_t () const;
+};
+} }
+
+#endif // BOOST_TP_WATER_MARK_H

Added: sandbox/async/libs/tp/build/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/build/Jamfile.v2 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,29 @@
+# Boost System Library Build Jamfile
+
+# (C) Copyright Oliver Kowalke 2009
+
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or www.boost.org/LICENSE_1_0.txt)
+
+# See library home page at http://www.boost.org/libs/system
+
+project boost/tp
+ : source-location ../src
+ : requirements
+ <include>../../..
+ <include>$(BOOST_ROOT)
+
+ : usage-requirements # pass these requirement to dependents (i.e. users)
+ <link>shared:<define>BOOST_THREADPOOL_DYN_LINK=1
+ <link>static:<define>BOOST_THREADPOOL_STATIC_LINK=1
+ ;
+
+SOURCES = callable default_pool guard interrupter poolsize scanns watermark worker ;
+
+static-lib boost_threadpool
+ : $(SOURCES).cpp
+ : #<link>shared:<define>BOOST_THREADPOOL_DYN_LINK=1
+ <link>static:<define>BOOST_THREADPOOL_STATIC_LINK=1
+ ;
+
+#boost-install boost_threadpool ;

Added: sandbox/async/libs/tp/doc/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/Jamfile.v2 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,12 @@
+# Boost.ThreadPool Library Documentation Jamfile
+
+# Copyright (C) 2008 Oliver Kowalke
+
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+using quickbook ;
+
+xml threadpool : threadpool.qbk ;
+boostbook standalone : threadpool ;

Added: sandbox/async/libs/tp/doc/acknowledgement.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/acknowledgement.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,11 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:acknowledgement Acknowledgements]
+I'd like to thank Vincente Botet Escriba for his comments on the implementation details of the code and
+Anthony Williams and Braddock Gaskill for their future libraries.
+[endsect]

Added: sandbox/async/libs/tp/doc/channel.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/channel.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,30 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:channel Channel]
+The channel synchronizes the access between application threads (producer threads) submitting __actions__ to the pool and __worker_threads__ (consumer threads). The scheduling of __actions__ queued into the channel depends on channels the scheduling policy.
+If the channel becomes empty all __worker_threads__ are set to sleep until a new __action__ is put in.
+
+[heading bounded channel]
+
+ template< typename SchedulingPolicy > class bounded_channel
+
+The number of pending __actions__ is limited in order to prevent resource exhaustion. For this purpose a high and low watermark has to be passed at construction.
+`boost::tp::high_watermark` sets the maximum of pending tasks. If this limited is reached all threads which submit a tasks will be set to sleep (blocked).
+`boost::tp::low_watermark` sets the threshold when blocked threads get woken up.
+If __hwm__ is equal to __lwm__ everytime a sleeping producer thread will be woken up and puts
+its task if one worker thread has taken a task from the channel.
+If __lwm__ is less than __hwm__ all sleeping producer threads will be woken up if
+the amount of pending tasks reaches __lwm__.
+
+[heading unbounded channel]
+
+ template< typename SchedulingPolicy > class unbounded_channel
+
+An unlimited number of __actions__ can be queued into this channel. The insertion of __actions__ will never block. If the channel becomes empty __worker_threads__ will be set to sleep until new __actions__ are inserted into the channel.
+
+[endsect]

Added: sandbox/async/libs/tp/doc/exceptions_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/exceptions_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,126 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:invalid_poolsize Class `invalid_poolsize`]
+
+ #include <boost/tp/exceptions.hpp>
+
+ class invalid_poolsize
+ : public std::invalid_argument
+ {
+ public:
+ invalid_poolsize( std::string const& msg);
+ };
+
+[section:constructor Constructor]
+
+ invalid_poolsize( std::string const& msg);
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::invalid_poolsize` instance.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]
+
+
+[section:invalid_scanns Class `invalid_scanns`]
+
+ #include <boost/tp/exceptions.hpp>
+
+ class invalid_scanns
+ : public std::invalid_argument
+ {
+ public:
+ invalid_scanns( std::string const& msg);
+ };
+
+[section:constructor Constructor]
+
+ invalid_scanns( std::string const& msg);
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::invalid_scanns` instance.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]
+
+
+[section:invalid_timeduration Class `invalid_timeduration`]
+
+ #include <boost/tp/exceptions.hpp>
+
+ class invalid_timeduration
+ : public std::invalid_argument
+ {
+ public:
+ invalid_timeduration( std::string const& msg);
+ };
+
+[section:constructor Constructor]
+
+ invalid_timeduration( std::string const& msg);
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::invalid_timeduration` instance.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]
+
+
+[section:invalid_watermark Class `invalid_watermark`]
+
+ #include <boost/tp/exceptions.hpp>
+
+ class invalid_watermark
+ : public std::invalid_argument
+ {
+ public:
+ invalid_watermark( std::string const& msg);
+ };
+
+[section:constructor Constructor]
+
+ invalid_watermark( std::string const& msg);
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::invalid_watermark` instance.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]
+
+
+[section:task_rejected Class `task_rejected`]
+
+ #include <boost/tp/exceptions.hpp>
+
+ class task_rejected
+ : public std::runtime_error
+ {
+ public:
+ task_rejected( std::string const& msg);
+ };
+
+[section:constructor Constructor]
+
+ task_rejected( std::string const& msg);
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::task_rejected` instance.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]
+

Added: sandbox/async/libs/tp/doc/forkjoin.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/forkjoin.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,102 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:forkjoin Fork/Join]
+Fork/Join algorithms are recursive divide-and-conquer algorithms which repeatedly splitt __sub_actions__ until they become small enough to solve using simple, short sequential methods, so that they run in parallel on multiple cores.
+
+The fork operation creates a new __sub_action__ (which can run in parallel) in the pool. The current __actions__ is not proceeded in the join operation until the forked __sub_actions__ have completed. In the meantime the __worker_thread__ executes other __actions__ from its local __worker_queue__.
+
+ // defines the threadpool type
+ namespace pt = boost::posix_time;
+ namespace tp = boost::tp;
+
+ typedef tp::pool< tp::unbounded_channel< tp::fifo > > pool_type;
+
+ class fibo
+ {
+ private:
+ int offset_;
+
+ int seq_( int n)
+ {
+ if ( n <= 1) return n;
+ else return seq_( n - 2) + seq_( n - 1);
+ }
+
+ int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 1) ) );
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 2) ) );
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+ public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+ };
+
+ int main( int argc, char *argv[])
+ {
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+ }
+[endsect]

Added: sandbox/async/libs/tp/doc/html/boost_threadpool/acknowledgement.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/boost_threadpool/acknowledgement.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,48 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Acknowledgements</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="prev" href="forkjoin.html" title="Fork/Join">
+<link rel="next" href="reference.html" title="Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="forkjoin.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.acknowledgement"></a><a class="link" href="acknowledgement.html" title="Acknowledgements"> Acknowledgements</a>
+</h2></div></div></div>
+
+ I'd like to thank Vincente Botet Escriba for his comments on the implementation
+ details of the code and Anthony Williams and Braddock Gaskill for their future
+ libraries.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Oliver Kowalke
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="forkjoin.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/html/boost_threadpool/channel.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/boost_threadpool/channel.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,79 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Channel</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="prev" href="this_task.html" title="Namespace this_task">
+<link rel="next" href="scheduling.html" title="Scheduling">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="this_task.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="scheduling.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.channel"></a><a class="link" href="channel.html" title="Channel"> Channel</a>
+</h2></div></div></div>
+
+ The channel synchronizes the access between application threads (producer threads)
+ submitting actions to the pool and worker threads (consumer threads). The scheduling
+ of actions queued into the channel depends on channels the scheduling policy.
+ If the channel becomes empty all worker threads are set to sleep until a new
+ action is put in.
+ 
+<a name="boost_threadpool.channel.bounded_channel"></a><h4>
+<a name="id372246"></a>
+ <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded channel</a>
+ </h4>
+<pre class="programlisting">template< typename SchedulingPolicy > class bounded_channel
+</pre>
+
+ The number of pending actions is limited in order to prevent resource exhaustion.
+ For this purpose a high and low watermark has to be passed at construction.
+ <code class="computeroutput">boost::tp::high_watermark</code>
+ sets the maximum of pending tasks. If this limited is reached all threads which
+ submit a tasks will be set to sleep (blocked). <code class="computeroutput">boost::tp::low_watermark</code> sets the threshold when blocked
+ threads get woken up. If high watermark is equal to low watermark everytime
+ a sleeping producer thread will be woken up and puts its task if one worker
+ thread has taken a task from the channel. If low watermark is less than high
+ watermark all sleeping producer threads will be woken up if the amount of pending
+ tasks reaches low watermark.
+ 
+<a name="boost_threadpool.channel.unbounded_channel"></a><h4>
+<a name="id372359"></a>
+ <a class="link" href="channel.html#boost_threadpool.channel.unbounded_channel">unbounded channel</a>
+ </h4>
+<pre class="programlisting">template< typename SchedulingPolicy > class unbounded_channel
+</pre>
+
+ An unlimited number of actions can be queued into this channel. The insertion
+ of actions will never block. If the channel becomes empty worker threads will
+ be set to sleep until new actions are inserted into the channel.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Oliver Kowalke
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="this_task.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="scheduling.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/html/boost_threadpool/forkjoin.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/boost_threadpool/forkjoin.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,773 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Fork/Join</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="prev" href="scheduling.html" title="Scheduling">
+<link rel="next" href="acknowledgement.html" title="Acknowledgements">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="scheduling.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgement.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.forkjoin"></a><a class="link" href="forkjoin.html" title="Fork/Join"> Fork/Join</a>
+</h2></div></div></div>
+
+ Fork/Join algorithms are recursive divide-and-conquer algorithms which repeatedly
+ splitt sub_actions until they become small enough to solve using simple, short
+ sequential methods, so that they run in parallel on multiple cores.
+ 
+
+ The fork operation creates a new sub_action (which can run in parallel) in
+ the pool. The current actions is not proceeded in the join operation until
+ the forked sub_actions have completed. In the meantime the worker thread executes
+ other actions from its local <a class="link" href="pool.html#boost_threadpool.pool.work_stealing">worker
+ queue</a>.
+ 
+<pre class="programlisting"> // defines the threadpool type
+ namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+typedef tp::pool< tp::unbounded_channel< tp::fifo > > pool_type;
+
+class fibo
+{
+private:
+ int offset_;
+
+ int seq_( int n)
+ {
+ if ( n <= 1) return n;
+ else return seq_( n - 2) + seq_( n - 1);
+ }
+
+ int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 1) ) );
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 2) ) );
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ // defines the threadpool type namespace pt = boost::posix_time; namespace
+ tp = boost::tp;
+ 
+<pre class="programlisting">typedef tp::pool< tp::unbounded_channel< tp::fifo > > pool_type;
+
+class fibo
+{
+private:
+ int offset_;
+
+ int seq_( int n)
+ {
+ if ( n <= 1) return n;
+ else return seq_( n - 2) + seq_( n - 1);
+ }
+
+ int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 1) ) );
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 2) ) );
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ typedef tp::pool< tp::unbounded_channel< tp::fifo > > pool_type;
+ 
+<pre class="programlisting">class fibo
+{
+private:
+ int offset_;
+
+ int seq_( int n)
+ {
+ if ( n <= 1) return n;
+ else return seq_( n - 2) + seq_( n - 1);
+ }
+
+ int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 1) ) );
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 2) ) );
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ class fibo { private: int offset_;
+ 
+<pre class="programlisting"> int seq_( int n)
+ {
+ if ( n <= 1) return n;
+ else return seq_( n - 2) + seq_( n - 1);
+ }
+
+ int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 1) ) );
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 2) ) );
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ int seq( int n) { if ( n <= 1) return n; else
+ return seq( n - 2) + seq_( n - 1); }
+ 
+<pre class="programlisting"> int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 1) ) );
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 2) ) );
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ int par( int n) { if ( n <= offset)
+ return seq_( n); else { tp::task< int > t1( boost::this_task::get_thread_pool<
+ pooltype >().submit( boost::bind( & fibo::par,
+ boost::ref( * this), n - 1) ) ); tp::task< int > t2( boost::this_task::get_thread_pool<
+ pooltype >().submit( boost::bind( & fibo::par,
+ boost::ref( * this), n - 2) ) ); return t1.result().get() + t2.result().get();
+ } }
+ 
+<pre class="programlisting">public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ public: fibo( int offset) : offset_( offset) {}
+ 
+<pre class="programlisting"> int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ int execute( int n) { int result( par_( n) ); return result; } };
+ 
+<pre class="programlisting">int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ int main( int argc, char *argv[]) { try { pool_type pool( tp::poolsize( 3)
+ ); fibo fib( 5); std::vector< tp::task< int > > results; results.reserve(
+ 40);
+ 
+<pre class="programlisting"> pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+ 
+<pre class="programlisting"> for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ for ( int i = 0; i < 32; ++i) results.push_back( pool.submit( boost::bind(
+ & fibo::execute, boost::ref( fib), i) ) );
+ 
+<pre class="programlisting"> int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ int k = 0; std::vector< tp::task< int > >::iterator e( results.end()
+ ); for ( std::vector< tp::task< int > >::iterator i( results.begin()
+ ); i != e; ++i) std::cout << "fibonacci " << k++ <<
+ " == " << i->result().get() << std::endl;
+ 
+<pre class="programlisting"> pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ pt::ptime stop( pt::microsec_clock::universal_time() ); std::cout <<
+ ( stop - start).total_milliseconds() << " milli seconds" <<
+ std::endl;
+ 
+<pre class="programlisting"> return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}
+</pre>
+
+ return EXIT_SUCCESS; } catch ( std::exception const& e) { std::cerr <<
+ "exception: " << e.what() << std::endl; } catch ( ...
+ ) { std::cerr << "unhandled" << std::endl; }
+ 
+<pre class="programlisting"> return EXIT_FAILURE;
+}
+</pre>
+
+ return EXIT_FAILURE; }
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Oliver Kowalke
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="scheduling.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgement.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/html/boost_threadpool/pool.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/boost_threadpool/pool.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,294 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Pool</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="prev" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="next" href="task.html" title="Task">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="task.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.pool"></a><a class="link" href="pool.html" title="Pool"> Pool</a>
+</h2></div></div></div>
+
+ The pool manages internaly worker threads and submitted actions are stored
+ in a <a class="link" href="channel.html" title="Channel">channel</a>
+ (<a class="link" href="pool.html#boost_threadpool.pool.work_stealing">global queue</a>)
+ for processing by the worker threads (using a <a class="link" href="pool.html#boost_threadpool.pool.work_stealing">work
+ stealing</a> algorithm). Each submitted action gets associated
+ with a <a class="link" href="task.html" title="Task">task</a>
+ object that will be returned. The <a class="link" href="task.html" title="Task">task</a>
+ object acts as a proxy for a result that is initially not known and gets evaluated
+ later by a worker thread.
+ 
+<a name="boost_threadpool.pool.work_stealing"></a><h4>
+<a name="id326427"></a>
+ <a class="link" href="pool.html#boost_threadpool.pool.work_stealing">Work-Stealing</a>
+ </h4>
+
+ Traditional thread poola do not scale because they use a single global queue
+ protected by a global lock. The frequency at which worker threads aquire the
+ global lock becomes a limiting factor for the throughput if:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ the actions become smaller
+ </li>
+<li>
+ more processors are added
+ </li>
+</ul></div>
+
+ A work-stealing algorithm can be used to solve this problem. It uses a special
+ kind of queue which has two ends, and allows lock-free pushes and pops from
+ the private end (accessed by the worker thread owning
+ the queue), but requires synchronization from the public end
+ (accessed by the other worker threads). Synchronization is necessary when the
+ queue is sufficiently small that private and public operations could conflict.
+ 
+
+ The pool contains one global queue (<a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a> or <a class="link" href="channel.html#boost_threadpool.channel.unbounded_channel">unbounded
+ channel</a>) protected by a global lock and each worker thread
+ has its own private worker queue. If work is enqueued by a worker thread the
+ action is stored in the worker queue. If the work is enqueued by a application
+ thread it goes into the global queue. When worker threads are looking for work,
+ they have following search order:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ look into the private worker queue - actions can be dequeued without locks
+ </li>
+<li>
+ look in the global queue - locks are used for synchronization
+ </li>
+<li>
+ check other worker queues ('stealing' actions from private worker queues
+ of other worker threads) - requires locks
+ </li>
+</ul></div>
+
+ For a lot of recursively queued actions, the use of a worker queue per thread
+ substantially reduces the synchronization necessary to complete the work. There
+ are also fewer cache effects due to sharing of the global queue information.
+ 
+
+ Operations on the private worker queue are executed in LIFO order and operations
+ on worker queues of other worker threads in FIFO order (steals).
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ There are chances that memory is still hot in the cache, if the actions are
+ pushed in LIFO order into the private worker queue.
+ </li>
+<li>
+ If a worker thread steals work in FIFO order, increases the chances that
+ a larger 'chunk' of work will be stolen (the need for other steals will be
+ possibly reduced). Because the actions are stored in LIFO order, the oldest
+ items are closer to the public end of the queue (forming
+ a tree). Stealing such an older action also steals a (probably) larger subtree
+ of actions unfolded if the stolen work item get executed.
+ </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ Actions submitted by a worker thread are stored into its private worker queue
+ in LIFO order, thatswhy priorities and timeouts specified at the submit-function
+ get ignored.
+ </td></tr>
+</table></div>
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../doc/html/images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top">
+ Because of the work-stealing algorithm the execution order of actions may
+ be not strict as in the global queue.
+ </td></tr>
+</table></div>
+<a name="boost_threadpool.pool.creation"></a><h4>
+<a name="id367654"></a>
+ <a class="link" href="pool.html#boost_threadpool.pool.creation">Creation</a>
+ </h4>
+
+ The first template argument specifies the channel type and the scheduling policy.
+ 
+<pre class="programlisting">boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+> pool(
+ boost::tp::poolsize( 6),
+ boost::posix_time::posix_time::milliseconds( 50),
+ boost::tp::scanns(10) );
+</pre>
+
+ In the example above a thread pool is created with a <a class="link" href="channel.html#boost_threadpool.channel.unbounded_channel">unbounded
+ channel</a>, scheduling actions in FIFO
+ order. The pool contains six worker threads going to sleep for 50 millisec
+ after 10 iterations without geting an action from the <a class="link" href="pool.html#boost_threadpool.pool.work_stealing">global
+ queue</a>, from its local <a class="link" href="pool.html#boost_threadpool.pool.work_stealing">worker
+ queue</a> or local queues of other worker threads.
+ 
+<pre class="programlisting">boost::tp::pool<
+ boost::tp::bounded_channel< boost::tp::priority < int > >
+> pool(
+ boost::tp::poolsize( 10),
+ boost::tp::high_watermark( 10),
+ boost::tp::low_watermark( 5) );
+</pre>
+
+ This pool uses a <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a> which schedules actions by integer atrributes. A
+ maximum of 10 actions can be queued in the <a class="link" href="pool.html#boost_threadpool.pool.work_stealing">global
+ queue</a> without blocking the inserting thread.
+ 
+<a name="boost_threadpool.pool.shutdown"></a><h4>
+<a name="id368155"></a>
+ <a class="link" href="pool.html#boost_threadpool.pool.shutdown">Shutdown</a>
+ </h4>
+
+ If <code class="computeroutput">boost::tp::pool< Channel >::shutdown()</code> is called - the the status of the pool is
+ set to terminating and all worker threads are joined.
+ No futher actions can be submitted by application threads. After all pending
+ actions are processed and all worker threads are joined, the pool is set to
+ status terminated.
+ 
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ The deconstructor calls <code class="computeroutput">boost::tp::pool< Channel >::shutdown()</code>
+ if the pool was not shutdown yet.
+ </td></tr>
+</table></div>
+<pre class="programlisting">boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+> pool( boost::tp::poolsize( 1) );
+
+boost::tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+boost::tp::task< int > t2(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+
+pool.shutdown();
+
+std::cout << t1.result().get() << std::endl; // 55
+std::cout << t2.result().get() << std::endl; // 55
+</pre>
+<a name="boost_threadpool.pool.shutdown_immediatly"></a><h4>
+<a name="id368800"></a>
+ <a class="link" href="pool.html#boost_threadpool.pool.shutdown_immediatly">Shutdown immediatly</a>
+ </h4>
+
+ The function <code class="computeroutput">boost::tp::pool< Channel >::shutdown_now()</code> sets the pool status to terminating
+ interrupts and then joins all worker threads. After the worker threads are
+ joined the status of the pool is set to terminated and
+ all pending (unprocessed) actions will be returned.
+ 
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../doc/html/images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top">
+ Pending actions in the local <a class="link" href="pool.html#boost_threadpool.pool.work_stealing">worker
+ queues</a> are not returned if <code class="computeroutput">boost::tp::pool< Channel >::shutdown_now()</code>
+ was called.
+ </td></tr>
+</table></div>
+<a name="boost_threadpool.pool.default_pool"></a><h4>
+<a name="id368934"></a>
+ <a class="link" href="pool.html#boost_threadpool.pool.default_pool">Default pool</a>
+ </h4>
+
+ The free function <code class="computeroutput">boost::tp::get_default_pool()</code> returns a reference to the default thread
+ pool instance. The default thread pool is of type <code class="computeroutput">boost::tp::pool< boost::tp::unbounded_channel< boost::tp::fifo > ></code> and will contain as many worker threads
+ as <code class="computeroutput">boost::thread::hardware_concurrency()</code>
+ returns.
+ 
+<a name="boost_threadpool.pool.meta_functions"></a><h4>
+<a name="id369097"></a>
+ <a class="link" href="pool.html#boost_threadpool.pool.meta_functions">Meta functions</a>
+ </h4>
+
+ If the thread pool supports priorities <code class="computeroutput">boost::tp::has_priority<
+ pool_type ></code>
+ evaluates to <code class="computeroutput">true</code>. The priority
+ type is determined by <code class="computeroutput">boost::tp::priority_type<
+ pool_type ></code>.
+ 
+<pre class="programlisting">typedef boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::priority< int > >
+> pool_type;
+
+std::cout << std::boolalpha << boost::tp::has_priority< pool_type >::value << std::endl;
+std::cout << typeid( boost::tp::priority_type< pool_type >::type).name() << std::endl;
+</pre>
+
+ The support of fibers can be tested with meta-function <code class="computeroutput">boost::tp::has_fibers<
+ pool_type ></code>.
+ 
+<pre class="programlisting">std::cout << std::boolalpha << boost::tp::has_fibers< pool_type >::value << std::endl;
+</pre>
+<a name="boost_threadpool.pool.processor_binding"></a><h4>
+<a name="id369670"></a>
+ <a class="link" href="pool.html#boost_threadpool.pool.processor_binding">Processor binding</a>
+ </h4>
+
+ For some applications it is convenient to bind the worker threads of the pool
+ to processors of the system. For this purpose BOOST_BIND_WORKER_TO_PROCESSORS
+ must be defined. Without the poolsize in the construtor the thread pool will
+ contain as many worker threads as processors (== boost::thread::hardware_concurrency)
+ are available and each worker thread is bound to one processor.
+ 
+<pre class="programlisting">boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+ > pool;
+</pre>
+
+ The code above will create a pool with two worker threads on a dual core system
+ (each bound to one core).
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Oliver Kowalke
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="task.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/html/boost_threadpool/reference.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/boost_threadpool/reference.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,1550 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Reference</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="prev" href="acknowledgement.html" title="Acknowledgements">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="acknowledgement.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.reference"></a><a class="link" href="reference.html" title="Reference"> Reference</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt> Class template pool</dt>
+<dt> Class template task</dt>
+<dt><a href="reference.html#boost_threadpool.reference.reschedule_until"> Non-member
+ function <code class="computeroutput">reschedule_until()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.get_thread_pool"> Non-member
+ function <code class="computeroutput">get_thread_pool()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.is_worker"> Non-member function
+ <code class="computeroutput">is_worker()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.worker_id"> Non-member function
+ <code class="computeroutput">worker_id()</code></a></dt>
+<dt> Class poolsize</dt>
+<dt> Class scanns</dt>
+<dt> Class high_watermark</dt>
+<dt> Class low_watermark</dt>
+<dt><a href="reference.html#boost_threadpool.reference.invalid_poolsize"> Class
+ <code class="computeroutput">invalid_poolsize</code></a></dt>
+<dt> Class invalid_scanns</dt>
+<dt><a href="reference.html#boost_threadpool.reference.invalid_timeduration"> Class
+ <code class="computeroutput">invalid_timeduration</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.invalid_watermark"> Class
+ <code class="computeroutput">invalid_watermark</code></a></dt>
+<dt> Class task_rejected</dt>
+<dt><a href="reference.html#boost_threadpool.reference.has_priority"> Meta function
+ <code class="computeroutput">has_priority</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.priority_type"> Meta function
+ <code class="computeroutput">priority_type</code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.pool"></a><a class="link" href="reference.html#boost_threadpool.reference.pool" title="Class template pool"> Class template <code class="computeroutput">pool</code></a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="reference.html#boost_threadpool.reference.pool.constructor_unbounded_channel_hw">
+ Constructor (unbounded channel)</a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.constructor_unbounded_channel">
+ Constructor (unbounded channel)</a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.constructor_bounded_channel_hw">
+ Constructor (bounded channel)</a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.constructor_bounded_channel">
+ Constructor (bounded channel)</a></dt>
+<dt> Destructor</dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.size"> Member function
+ <code class="computeroutput">size()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.active"> Member function
+ <code class="computeroutput">active()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.idle"> Member function
+ <code class="computeroutput">idle()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.shutdown"> Member function
+ <code class="computeroutput">shutdown()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.shutdown_now"> Member
+ function <code class="computeroutput">shutdown_now()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.terminated"> Member
+ function <code class="computeroutput">terminated()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.terminateing"> Member
+ function <code class="computeroutput">terminateing()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.clear"> Member function
+ <code class="computeroutput">clear()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.empty"> Member function
+ <code class="computeroutput">empty()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.pending"> Member function
+ <code class="computeroutput">pending()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.get_upper_bound"> Member
+ function <code class="computeroutput">upper_bound()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.set_upper_bound"> Member
+ function <code class="computeroutput">upper_bound(
+ high_watermark const& hwm)</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.get_lower_bound"> Member
+ function <code class="computeroutput">lower_bound()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.set_lower_bound"> Member
+ function <code class="computeroutput">lower_bound(
+ low_watermark const& lwm)</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.submit"> Member function
+ <code class="computeroutput">submit(
+ Act const& act)</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.submit_attr"> Member
+ function <code class="computeroutput">submit(
+ Act const& act, Attr const& attr)</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.pool.get_default_pool">
+ Non-member function <code class="computeroutput">get_default_pool()</code></a></dt>
+</dl></div>
+<pre class="programlisting"> #include <boost/tp/pool.hpp>
+
+ template< typename Channel >
+ class pool
+ : private noncopyable
+ {
+ public:
+ explicit pool(
+ poolsize const& psize,
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) );
+
+ explicit pool(
+ poolsize const& psize,
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::milliseconds( 100),
+ scanns const& scns = scanns( 20) );
+
+
+ explicit pool(
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) );
+
+ explicit pool(
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::milliseconds( 100),
+ scanns const& scns = scanns( 20) );
+
+ ~pool();
+
+ std::size_t size();
+ std::size_t active();
+ std::size_t idle();
+
+ void shutdown();
+ const std::vector< callable > shutdown_now();
+
+ bool terminated();
+ bool terminateing();
+ void clear();
+ bool empty();
+ std::size_t pending();
+
+ const std::size_t upper_bound();
+ void upper_bound( high_watermark const& hwm);
+ const std::size_t lower_bound();
+ void lower_bound( low_watermark const& lwm);
+
+ template< typename Act >
+ task< typename result_of< Act() >::type > submit( Act const& act);
+
+ template< typename Act, typename Attr >
+ task< typename result_of< Act() >::type > submit(
+ Act const& act,
+ Attr const& attr);
+ };
+
+pool< unbounded_channel< fifo > > & get_default_pool();
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.constructor_unbounded_channel_hw"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.constructor_unbounded_channel_hw" title="Constructor (unbounded channel)">
+ Constructor (unbounded channel)</a>
+</h4></div></div></div>
+<pre class="programlisting">explicit pool(
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) );
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ Operating system provides functionality for processor pining.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::pool< Channel
+ ></code> instance. For each processor
+ a worker-thread is created and each worker-thread is pined exactly
+ to one processor.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_scanns</code>, <code class="computeroutput">boost::tp::invalid_timeduration</code>
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Constructor has to be called if a <a class="link" href="channel.html#boost_threadpool.channel.unbounded_channel">unbounded
+ channel</a> is used.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.constructor_unbounded_channel"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.constructor_unbounded_channel" title="Constructor (unbounded channel)">
+ Constructor (unbounded channel)</a>
+</h4></div></div></div>
+<pre class="programlisting">explicit pool(
+ poolsize const& psize,
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) );
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::pool< Channel
+ ></code> instance. Pool contains
+ psize worker-threads.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_scanns</code>, <code class="computeroutput">boost::tp::invalid_timeduration</code>
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Constructor has to be called if a <a class="link" href="channel.html#boost_threadpool.channel.unbounded_channel">unbounded
+ channel</a> is used.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.constructor_bounded_channel_hw"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.constructor_bounded_channel_hw" title="Constructor (bounded channel)">
+ Constructor (bounded channel)</a>
+</h4></div></div></div>
+<pre class="programlisting">explicit pool(
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::milliseconds( 100),
+ scanns const& scns = scanns( 20) );
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ Operating system provides functionality for processor pining.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::pool< Channel
+ ></code> instance. For each processor
+ a worker-thread is created and each worker-thread is pined exactly
+ to one processor.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_scanns</code>, <code class="computeroutput">boost::tp::invalid_timeduration</code>,
+ <code class="computeroutput">boost::tp::invalid_watermark</code>
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Constructor has to be called if a <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a> is used.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.constructor_bounded_channel"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.constructor_bounded_channel" title="Constructor (bounded channel)">
+ Constructor (bounded channel)</a>
+</h4></div></div></div>
+<pre class="programlisting">explicit pool(
+ poolsize const& psize,
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::milliseconds( 100),
+ scanns const& scns = scanns( 20) );
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::pool< Channel
+ ></code> instance. Pool contains
+ psize worker-threads.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_scanns</code>, <code class="computeroutput">boost::tp::invalid_timeduration</code>,
+ <code class="computeroutput">boost::tp::invalid_watermark</code>
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Constructor has to be called if a <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a> is used.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.destructor"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.destructor" title="Destructor"> Destructor</a>
+</h4></div></div></div>
+<pre class="programlisting">~pool();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Calls <code class="computeroutput">boost::tp::pool<
+ Channel >::shutdown()</code>
+ if not yet called.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.size"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.size" title="Member function size()"> Member function
+ <code class="computeroutput">size()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">std::size_t size();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns how many worker threads are running in the pool.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.active"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.active" title="Member function active()"> Member function
+ <code class="computeroutput">active()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">std::size_t active();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns how many worker threads are active (executing an action).
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.idle"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.idle" title="Member function idle()"> Member function
+ <code class="computeroutput">idle()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">std::size_t idle();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns how many worker threads are idle (not executing an action).
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ The value is the difference of <code class="computeroutput">size()</code> and <code class="computeroutput">active()</code>
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.shutdown"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.shutdown" title="Member function shutdown()"> Member function
+ <code class="computeroutput">shutdown()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">void shutdown();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Changes the pool state to terminating, deactivates
+ the channel and joins all worker threads. The status of the pool is
+ assigned to terminated at the end.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ All pending actions are processed.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.shutdown_now"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.shutdown_now" title="Member function shutdown_now()"> Member
+ function <code class="computeroutput">shutdown_now()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">const std::vector< callable > shutdown_now();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Changes the pool state to terminating, deactivates
+ the channel, send interruption request to all worker threads and joins
+ them. The status of the pool is assigned to terminated
+ at the end.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Pending actions are not processed but returned.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.terminated"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.terminated" title="Member function terminated()"> Member
+ function <code class="computeroutput">terminated()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">bool terminated();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Queries if the pool is in the terminated state (pool is shutdown).
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.terminateing"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.terminateing" title="Member function terminateing()"> Member
+ function <code class="computeroutput">terminateing()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">bool terminateing();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Queries if the pool is in the terminating state (tries to shutdown
+ the pool).
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.clear"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.clear" title="Member function clear()"> Member function
+ <code class="computeroutput">clear()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">void clear();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Removes all pending actions from the <a class="link" href="channel.html" title="Channel">channel</a>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.empty"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.empty" title="Member function empty()"> Member function
+ <code class="computeroutput">empty()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">bool empty();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Queries if the <a class="link" href="channel.html" title="Channel">channel</a>
+ is empty.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.pending"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.pending" title="Member function pending()"> Member function
+ <code class="computeroutput">pending()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">std::size_t pending();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Queries how many actions are pending in the <a class="link" href="channel.html" title="Channel">channel</a>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.get_upper_bound"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.get_upper_bound" title="Member function upper_bound()"> Member
+ function <code class="computeroutput">upper_bound()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">std::size_t upper_bound();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ Channel is of type <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a>.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Returns the upper bound of the <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Can only be used if a <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a> is used.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.set_upper_bound"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.set_upper_bound" title="Member function upper_bound( high_watermark const& hwm)"> Member
+ function <code class="computeroutput">upper_bound(
+ high_watermark const& hwm)</code></a>
+</h4></div></div></div>
+<pre class="programlisting">void upper_bound( high_watermark const& hwm);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ Channel is of type <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a>.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Sets the upper bound of the <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a>.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ <code class="computeroutput">this->upper_bound()
+ == hwm</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_watermark</code>
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Can only be used if a <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a> is used.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.get_lower_bound"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.get_lower_bound" title="Member function lower_bound()"> Member
+ function <code class="computeroutput">lower_bound()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">std::size_t lower_bound();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ Channel is of type <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a>.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Returns the lower bound of the <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Can only be used if a <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a> is used.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.set_lower_bound"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.set_lower_bound" title="Member function lower_bound( low_watermark const& lwm)"> Member
+ function <code class="computeroutput">lower_bound(
+ low_watermark const& lwm)</code></a>
+</h4></div></div></div>
+<pre class="programlisting">void lower_bound( low_watermark const& lwm);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ Channel is of type <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a>.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Sets the lower bound of the <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a>.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ <code class="computeroutput">this->lower_bound()
+ == lwm</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_watermark</code>
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ Can only be used if a <a class="link" href="channel.html#boost_threadpool.channel.bounded_channel">bounded
+ channel</a> is used.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.submit"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.submit" title="Member function submit( Act const& act)"> Member function
+ <code class="computeroutput">submit(
+ Act const& act)</code></a>
+</h4></div></div></div>
+<pre class="programlisting">template< typename Act >
+task< typename result_of< Act() >::type > submit( Act const& act);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ has_priority< pool >::value == false && ! ( pool.terminating()
+ || pool.terminated() )
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Submits an action to the pool and returns a <a class="link" href="task.html" title="Task">task</a>
+ object.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::task_rejected</code>
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.submit_attr"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.submit_attr" title="Member function submit( Act const& act, Attr const& attr)"> Member
+ function <code class="computeroutput">submit(
+ Act const& act, Attr const& attr)</code></a>
+</h4></div></div></div>
+<pre class="programlisting">template< typename Act, typename Attr >
+task< typename result_of< Act() >::type > submit( Act const& act, Attr const& attr);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ has_priority< pool >::value == true && ! ( pool.terminating()
+ || pool.terminated() )
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Submits an action to the pool and returns a <a class="link" href="task.html" title="Task">task</a>
+ object. _Action_ is scheduled
+ by the attribute.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::task_rejected</code>
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.pool.get_default_pool"></a><a class="link" href="reference.html#boost_threadpool.reference.pool.get_default_pool" title="Non-member function get_default_pool()">
+ Non-member function <code class="computeroutput">get_default_pool()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">pool< unbounded_channel< fifo > > & get_default_pool();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Get access to default thread pool (static).
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.task"></a><a class="link" href="reference.html#boost_threadpool.reference.task" title="Class template task"> Class template <code class="computeroutput">task</code></a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt> Constructor</dt>
+<dt><a href="reference.html#boost_threadpool.reference.task.interrupt"> Member
+ function <code class="computeroutput">interrupt()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.task.interrupt_and_wait">
+ Member function <code class="computeroutput">interrupt_and_wait()</code></a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.task.result"> Member function
+ <code class="computeroutput">result()</code></a></dt>
+</dl></div>
+<pre class="programlisting">#include <boost/tp/task.hpp>
+
+template< typename R >
+class task
+{
+public:
+ template< typename Pool >
+ task(
+ Pool * pool,
+ shared_future< R > const& fut,
+ detail::interrupter const& intr);
+
+ void interrupt();
+ void interrupt_and_wait();
+ void interrupt_and_wait( system_time const& abs_time);
+ template< typename Duration >
+ void interrupt_and_wait( Duration const& rel_time);
+ bool interrupt_requested();
+
+ shared_future< R > result() const;
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.task.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.task.constructor" title="Constructor"> Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">template< typename Pool >
+task(
+ Pool * pool,
+ shared_future< R > const& fut,
+ detail::interrupter const& intr);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::task< R
+ ></code> instance.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Notes:</dt>
+<dd>
+ task objects should only be constructed by the pool.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.task.interrupt"></a><a class="link" href="reference.html#boost_threadpool.reference.task.interrupt" title="Member function interrupt()"> Member
+ function <code class="computeroutput">interrupt()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">void interrupt();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Associated action will be interrupted the next time it enters a <a class="link" href="task.html#boost_threadpool.task.interruption">interruption
+ point</a> if interruption is not disabled. The function
+ returns immediatly.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.task.interrupt_and_wait"></a><a class="link" href="reference.html#boost_threadpool.reference.task.interrupt_and_wait" title="Member function interrupt_and_wait()">
+ Member function <code class="computeroutput">interrupt_and_wait()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">void interrupt_and_wait();
+
+void interrupt_and_wait( system_time const& abs_time);
+
+template< typename DurationTime >
+void interrupt_and_wait( DurationTime const& rel_time);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Associated action will be interrupted the next time it enters one
+ <a class="link" href="task.html#boost_threadpool.task.interruption">interruption
+ point</a> if interruption is not disabled. The function
+ waits until the action has terminated or the specified duration td
+ has elapsed.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.task.result"></a><a class="link" href="reference.html#boost_threadpool.reference.task.result" title="Member function result()"> Member function
+ <code class="computeroutput">result()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">shared_future< R > result() const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns fulfilled value or throws fulfilled exception via a shared_future.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::future::broken_promise</code>
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.reschedule_until"></a><a class="link" href="reference.html#boost_threadpool.reference.reschedule_until" title="Non-member function reschedule_until()"> Non-member
+ function <code class="computeroutput">reschedule_until()</code></a>
+</h3></div></div></div>
+<pre class="programlisting"> #include <boost/tp/pool.hpp>
+
+template< typename Pred >
+void reschedule_until( Pred const&);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+
+ Reschedules current task until passed callable predicate becomes ready.
+ 
+
+ [Throws:
+ 
+
+ Nothing.
+ 
+</dd>
+<dt>Note:</dt>
+<dd>
+ This function resides in namespace <code class="computeroutput">boost::this_task</code>.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.get_thread_pool"></a><a class="link" href="reference.html#boost_threadpool.reference.get_thread_pool" title="Non-member function get_thread_pool()"> Non-member
+ function <code class="computeroutput">get_thread_pool()</code></a>
+</h3></div></div></div>
+<pre class="programlisting"> #include <boost/tp/pool.hpp>
+
+template< typename Pool >
+Pool & get_thread_pool();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+
+ Returns reference to the thread pool where the current worker thread
+ is running.
+ 
+
+ [Throws:
+ 
+
+ Nothing.
+ 
+</dd>
+<dt>Note:</dt>
+<dd>
+ This function resides in namespace <code class="computeroutput">boost::this_task</code>.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.is_worker"></a><a class="link" href="reference.html#boost_threadpool.reference.is_worker" title="Non-member function is_worker()"> Non-member function
+ <code class="computeroutput">is_worker()</code></a>
+</h3></div></div></div>
+<pre class="programlisting"> #include <boost/tp/pool.hpp>
+
+bool is_worker();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+
+ Returns true if the current thread is a worker-thread form a pool.
+ 
+
+ [Throws:
+ 
+
+ Nothing.
+ 
+</dd>
+<dt>Note:</dt>
+<dd>
+ This function resides in namespace <code class="computeroutput">boost::this_task</code>.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.worker_id"></a><a class="link" href="reference.html#boost_threadpool.reference.worker_id" title="Non-member function worker_id()"> Non-member function
+ <code class="computeroutput">worker_id()</code></a>
+</h3></div></div></div>
+<pre class="programlisting"> #include <boost/tp/pool.hpp>
+
+thread::id worker_id();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+
+ Returns returns the thread-id of the worker-thread.
+ 
+
+ [Throws:
+ 
+
+ Nothing.
+ 
+</dd>
+<dt>Note:</dt>
+<dd>
+ This function resides in namespace <code class="computeroutput">boost::this_task</code>.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.poolsize"></a><a class="link" href="reference.html#boost_threadpool.reference.poolsize" title="Class poolsize"> Class <code class="computeroutput">poolsize</code></a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt> Constructor</dt>
+<dt><a href="reference.html#boost_threadpool.reference.poolsize.operator"> Member
+ function <code class="computeroutput">operator std::size_t()</code></a></dt>
+</dl></div>
+<pre class="programlisting">#include <boost/tp/poolsize.hpp>
+
+class poolsize
+{
+public:
+ explicit poolsize( std::size_t value);
+
+ operator std::size_t () const;
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.poolsize.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.poolsize.constructor" title="Constructor"> Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">explicit poolsize( std::size_t value);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ value > 0
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::poolsize</code>
+ instance.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ operator std::size_t () > 0
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_poolsize</code>
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.poolsize.operator"></a><a class="link" href="reference.html#boost_threadpool.reference.poolsize.operator" title="Member function operator std::size_t()"> Member
+ function <code class="computeroutput">operator std::size_t()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">operator std::size_t () const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns pool size.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.scanns"></a><a class="link" href="reference.html#boost_threadpool.reference.scanns" title="Class scanns"> Class <code class="computeroutput">scanns</code></a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt> Constructor</dt>
+<dt><a href="reference.html#boost_threadpool.reference.scanns.operator"> Member
+ function <code class="computeroutput">operator std::size_t()</code></a></dt>
+</dl></div>
+<pre class="programlisting">#include <boost/tp/scanns.hpp>
+
+class scanns
+{
+public:
+ explicit scanns( std::size_t value);
+
+ operator std::size_t () const;
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.scanns.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.scanns.constructor" title="Constructor"> Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">explicit scanns( std::size_t value);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ value >= 0
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::scanns</code>
+ instance.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ operator std::size_t () >= 0
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_scanns</code>
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.scanns.operator"></a><a class="link" href="reference.html#boost_threadpool.reference.scanns.operator" title="Member function operator std::size_t()"> Member
+ function <code class="computeroutput">operator std::size_t()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">operator std::size_t () const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns scanns size.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.high_watermark"></a><a class="link" href="reference.html#boost_threadpool.reference.high_watermark" title="Class high_watermark"> Class <code class="computeroutput">high_watermark</code></a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="reference.html#boost_threadpool.reference.high_watermark.constructor">
+ Constructor</a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.high_watermark.operator">
+ Member function <code class="computeroutput">operator std::size_t()</code></a></dt>
+</dl></div>
+<pre class="programlisting">#include <boost/tp/watermark.hpp>
+
+class high_watermark
+{
+public:
+ explicit high_watermark( std::size_t value);
+
+ operator std::size_t () const;
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.high_watermark.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.high_watermark.constructor" title="Constructor">
+ Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">explicit high_watermark( std::size_t value);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::high_watermark</code>
+ instance.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_watermark</code>
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.high_watermark.operator"></a><a class="link" href="reference.html#boost_threadpool.reference.high_watermark.operator" title="Member function operator std::size_t()">
+ Member function <code class="computeroutput">operator std::size_t()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">operator std::size_t () const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns high watermark.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.low_watermark"></a><a class="link" href="reference.html#boost_threadpool.reference.low_watermark" title="Class low_watermark"> Class <code class="computeroutput">low_watermark</code></a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="reference.html#boost_threadpool.reference.low_watermark.constructor">
+ Constructor</a></dt>
+<dt><a href="reference.html#boost_threadpool.reference.low_watermark.operator">
+ Member function <code class="computeroutput">operator std::size_t()</code></a></dt>
+</dl></div>
+<pre class="programlisting">#include <boost/tp/watermark.hpp>
+
+class low_watermark
+{
+public:
+ explicit low_watermark( std::size_t value);
+
+ operator std::size_t () const;
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.low_watermark.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.low_watermark.constructor" title="Constructor">
+ Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">explicit low_watermark( std::size_t value);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::low_watermark</code>
+ instance.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::tp::invalid_watermark</code>
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.low_watermark.operator"></a><a class="link" href="reference.html#boost_threadpool.reference.low_watermark.operator" title="Member function operator std::size_t()">
+ Member function <code class="computeroutput">operator std::size_t()</code></a>
+</h4></div></div></div>
+<pre class="programlisting">operator std::size_t () const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns low watermark.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.invalid_poolsize"></a><a class="link" href="reference.html#boost_threadpool.reference.invalid_poolsize" title="Class invalid_poolsize"> Class
+ <code class="computeroutput">invalid_poolsize</code></a>
+</h3></div></div></div>
+<div class="toc"><dl><dt><a href="reference.html#boost_threadpool.reference.invalid_poolsize.constructor">
+ Constructor</a></dt></dl></div>
+<pre class="programlisting">#include <boost/tp/exceptions.hpp>
+
+class invalid_poolsize
+: public std::invalid_argument
+{
+public:
+ invalid_poolsize( std::string const& msg);
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.invalid_poolsize.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.invalid_poolsize.constructor" title="Constructor">
+ Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">invalid_poolsize( std::string const& msg);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::invalid_poolsize</code>
+ instance.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.invalid_scanns"></a><a class="link" href="reference.html#boost_threadpool.reference.invalid_scanns" title="Class invalid_scanns"> Class <code class="computeroutput">invalid_scanns</code></a>
+</h3></div></div></div>
+<div class="toc"><dl><dt><a href="reference.html#boost_threadpool.reference.invalid_scanns.constructor">
+ Constructor</a></dt></dl></div>
+<pre class="programlisting">#include <boost/tp/exceptions.hpp>
+
+class invalid_scanns
+: public std::invalid_argument
+{
+public:
+ invalid_scanns( std::string const& msg);
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.invalid_scanns.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.invalid_scanns.constructor" title="Constructor">
+ Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">invalid_scanns( std::string const& msg);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::invalid_scanns</code>
+ instance.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.invalid_timeduration"></a><a class="link" href="reference.html#boost_threadpool.reference.invalid_timeduration" title="Class invalid_timeduration"> Class
+ <code class="computeroutput">invalid_timeduration</code></a>
+</h3></div></div></div>
+<div class="toc"><dl><dt><a href="reference.html#boost_threadpool.reference.invalid_timeduration.constructor">
+ Constructor</a></dt></dl></div>
+<pre class="programlisting">#include <boost/tp/exceptions.hpp>
+
+class invalid_timeduration
+: public std::invalid_argument
+{
+public:
+ invalid_timeduration( std::string const& msg);
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.invalid_timeduration.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.invalid_timeduration.constructor" title="Constructor">
+ Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">invalid_timeduration( std::string const& msg);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::invalid_timeduration</code>
+ instance.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.invalid_watermark"></a><a class="link" href="reference.html#boost_threadpool.reference.invalid_watermark" title="Class invalid_watermark"> Class
+ <code class="computeroutput">invalid_watermark</code></a>
+</h3></div></div></div>
+<div class="toc"><dl><dt><a href="reference.html#boost_threadpool.reference.invalid_watermark.constructor">
+ Constructor</a></dt></dl></div>
+<pre class="programlisting">#include <boost/tp/exceptions.hpp>
+
+class invalid_watermark
+: public std::invalid_argument
+{
+public:
+ invalid_watermark( std::string const& msg);
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.invalid_watermark.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.invalid_watermark.constructor" title="Constructor">
+ Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">invalid_watermark( std::string const& msg);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::invalid_watermark</code>
+ instance.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.task_rejected"></a><a class="link" href="reference.html#boost_threadpool.reference.task_rejected" title="Class task_rejected"> Class <code class="computeroutput">task_rejected</code></a>
+</h3></div></div></div>
+<div class="toc"><dl><dt><a href="reference.html#boost_threadpool.reference.task_rejected.constructor">
+ Constructor</a></dt></dl></div>
+<pre class="programlisting">#include <boost/tp/exceptions.hpp>
+
+class task_rejected
+: public std::runtime_error
+{
+public:
+ task_rejected( std::string const& msg);
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_threadpool.reference.task_rejected.constructor"></a><a class="link" href="reference.html#boost_threadpool.reference.task_rejected.constructor" title="Constructor">
+ Constructor</a>
+</h4></div></div></div>
+<pre class="programlisting">task_rejected( std::string const& msg);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Constructs a <code class="computeroutput">boost::tp::task_rejected</code>
+ instance.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.has_priority"></a><a class="link" href="reference.html#boost_threadpool.reference.has_priority" title="Meta function has_priority"> Meta function
+ <code class="computeroutput">has_priority</code></a>
+</h3></div></div></div>
+<pre class="programlisting">#include <boost/tp/info.hpp>
+
+template< typename Pool >
+struct has_priority
+:
+public mpl::bool_<
+ is_same<
+ detail::has_priority,
+ typename Pool::scheduler_type::priority_tag_type
+ >::value
+>
+{};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_threadpool.reference.priority_type"></a><a class="link" href="reference.html#boost_threadpool.reference.priority_type" title="Meta function priority_type"> Meta function
+ <code class="computeroutput">priority_type</code></a>
+</h3></div></div></div>
+<pre class="programlisting">#include <boost/tp/info.hpp>
+
+template< typename Pool >
+struct priority_type
+{
+ typedef typename Pool::scheduler_type::attribute_type type;
+};
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Oliver Kowalke
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="acknowledgement.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
+</div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/html/boost_threadpool/scheduling.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/boost_threadpool/scheduling.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,132 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Scheduling</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="prev" href="channel.html" title="Channel">
+<link rel="next" href="forkjoin.html" title="Fork/Join">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="channel.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="forkjoin.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.scheduling"></a><a class="link" href="scheduling.html" title="Scheduling"> Scheduling</a>
+</h2></div></div></div>
+
+ The scheduling policy determines how actions are scheduled inside the <a class="link" href="channel.html" title="Channel">channel</a>.
+ 
+<a name="boost_threadpool.scheduling.fifo"></a><h4>
+<a name="id372440"></a>
+ <a class="link" href="scheduling.html#boost_threadpool.scheduling.fifo">fifo</a>
+ </h4>
+<pre class="programlisting">struct fifo
+</pre>
+
+ First inserted pending action get taken first.
+ 
+<a name="boost_threadpool.scheduling.lifo"></a><h4>
+<a name="id372473"></a>
+ <a class="link" href="scheduling.html#boost_threadpool.scheduling.lifo">lifo</a>
+ </h4>
+<pre class="programlisting">struct lifo
+</pre>
+
+ Last inserted pending action get taken first.
+ 
+<a name="boost_threadpool.scheduling.priority"></a><h4>
+<a name="id372506"></a>
+ <a class="link" href="scheduling.html#boost_threadpool.scheduling.priority">priority</a>
+ </h4>
+<pre class="programlisting">template< typename Attr, typename Ord = std::less< Attr > > struct priority
+</pre>
+
+ Each pending task is associated with a priority attribute which is used for
+ ordering actions.
+ 
+<a name="boost_threadpool.scheduling.smart"></a><h4>
+<a name="id372612"></a>
+ <a class="link" href="scheduling.html#boost_threadpool.scheduling.smart">smart</a>
+ </h4>
+<pre class="programlisting">template< typename Attr, typename Ord, typename Enq, typename Deq > struct smart
+</pre>
+
+ Each pending actions is associated with an attribute. The scheduler gets an
+ put- and take-policy as template arguments. The corresponding policy get applied
+ for each insertion and removal.
+ 
+
+ Boost.Threadpool provides boost::tp::replace_oldest
+ as put policy and boost::tp::take_oldest as take policy.
+ Both policies allow the replacement of old actions in the scheduler by new
+ ones.
+ 
+<pre class="programlisting">// creates a pool with unbounded channel
+// tasks are processed depending on the associated attributed
+// oldest tasks with the same attributed pending in the channel
+// will be replaced by the new task
+// this example would execute add( 1, 2) and add( 5, 6)
+// add( 2, 3) is removed (if pending when add( 5, 6) is submitted)
+boost::tp::pool<
+ boost::tp::unbounded_channel<
+ boost::tp::smart<
+ int,
+ std::less< int >,
+ boost::tp::replace_oldest,
+ boost::tp::take_oldest
+ >
+ >
+> pool( boost::tp::poolsize( 1) );
+
+pool.submit(
+ boost::bind(
+ add_fn,
+ 1,
+ 2),
+ 0);
+
+// replaced by later task with same attribute
+// if still pending in pool
+pool.submit(
+ boost::bind(
+ add_fn,
+ 3,
+ 4),
+ 1);
+
+// will replace previous pending action
+pool.submit(
+ boost::bind(
+ add_fn,
+ 5,
+ 6),
+ 1);
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Oliver Kowalke
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="channel.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="forkjoin.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/html/boost_threadpool/task.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/boost_threadpool/task.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,185 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Task</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="prev" href="pool.html" title="Pool">
+<link rel="next" href="this_task.html" title="Namespace this_task">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="pool.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="this_task.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.task"></a><a class="link" href="task.html" title="Task"> Task</a>
+</h2></div></div></div>
+
+ For each submitted action a new task object will be created and returned by
+ the pool. The <a class="link" href="task.html" title="Task">task</a>
+ object acts as a proxy for a result that is initially not known and gets evaluated
+ later by a worker thread. It transports the result (value or exception) of
+ the action back to the caller.
+ 
+<pre class="programlisting">boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+> pool( boost::tp::poolsize( 10) );
+
+// task calculates fibonacci(10)
+// scheduled in unbounded channel with FIFO ordering
+boost::tp::task< int > t(
+pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+
+std::cout << t.result().get() << std::endl; // 55
+</pre>
+<a name="boost_threadpool.task.interruption"></a><h4>
+<a name="id370144"></a>
+ <a class="link" href="task.html#boost_threadpool.task.interruption">Interruption</a>
+ </h4>
+
+ The returned <a class="link" href="task.html" title="Task">task</a>
+ object provides the possiblity to interrupt an action if it is cooperative.
+ An action is known as cooperative if it includes interruption points in its
+ code:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput">boost::thread::join()</code></li>
+<li><code class="computeroutput">boost::thread::timed_join()</code></li>
+<li><code class="computeroutput">boost::condition_variable::wait()</code></li>
+<li><code class="computeroutput">boost::condition_variable::timed_wait()</code></li>
+<li><code class="computeroutput">boost::condition_variable_any::wait()</code></li>
+<li><code class="computeroutput">boost::condition_variable_any::timed_wait()</code></li>
+<li><code class="computeroutput">boost::thread::sleep()</code></li>
+<li><code class="computeroutput">boost::this_thread::sleep()</code></li>
+<li><code class="computeroutput">boost::this_thread::interruption_point()</code></li>
+</ul></div>
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../doc/html/images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top">
+ Interruption must not be disabled for the worker thread (class boost::this_thread::disable_interruption).
+ </td></tr>
+</table></div>
+
+ The action will be interrupted even if it is pending (interruption is remembered).
+ A boost::thread_interrupted exception will be thrown by
+ <code class="computeroutput">boost::tp::task< T >::get()</code> if
+ the action was interrupted.
+
+<pre class="programlisting">boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+> pool( boost::tp::poolsize( 10) );
+
+// submit a long running task
+boost::tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ long_running_fn) ) );
+
+// interrupt task
+t.interrupt();
+
+// throws boost::thread_interrupted exception
+std::cout << t.result().get() << std::endl;
+</pre>
+
+ 
+<pre class="programlisting">boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+> pool( boost::tp::poolsize( 10) );
+
+// submit a long running task
+boost::tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ long_running_fn) ) );
+
+// interrupt task and wait for its termination
+t.interrupt_and_wait();
+
+// throws boost::thread_interrupted exception
+std::cout << t.result().get() << std::endl;
+</pre>
+<a name="boost_threadpool.task.exceptions_in_tasks"></a><h4>
+<a name="id371198"></a>
+ <a class="link" href="task.html#boost_threadpool.task.exceptions_in_tasks">Exceptions in tasks</a>
+ </h4>
+
+ Exceptions thrown inside an action are transported by the associated task object.
+ Exceptions rethrown by type:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput">std::bad_alloc</code></li>
+<li><code class="computeroutput">std::bad_cast</code></li>
+<li><code class="computeroutput">std::bad_exception</code></li>
+<li><code class="computeroutput">std::bad_typeid</code></li>
+<li><code class="computeroutput">std::domain_error</code></li>
+<li><code class="computeroutput">std::invalid_argument</code></li>
+<li><code class="computeroutput">std::ios_base::failure</code></li>
+<li><code class="computeroutput">std::length_error</code></li>
+<li><code class="computeroutput">std::logic_error</code></li>
+<li><code class="computeroutput">std::out_of_range</code></li>
+<li><code class="computeroutput">std::overflow_error</code></li>
+<li><code class="computeroutput">std::range_error</code></li>
+<li><code class="computeroutput">std::runtime_error</code></li>
+<li><code class="computeroutput">std::underflow_error</code></li>
+<li><code class="computeroutput">boost::broken_promise</code></li>
+<li><code class="computeroutput">boost::future_already_set</code></li>
+<li><code class="computeroutput">boost::future_cancel</code></li>
+<li><code class="computeroutput">boost::invalid_thread_argument</code></li>
+<li><code class="computeroutput">boost::lock_error</code></li>
+<li><code class="computeroutput">boost::thread_exception</code></li>
+<li><code class="computeroutput">boost::thread_interrupted</code></li>
+<li><code class="computeroutput">boost::thread_permission_error</code></li>
+<li><code class="computeroutput">boost::thread_resource_error</code></li>
+<li><code class="computeroutput">boost::unsupported_thread_option</code></li>
+</ul></div>
+
+ Exceptions derived from <code class="computeroutput">std::exception</code>
+ will be rethrown as <code class="computeroutput">std::runtime_error</code> in all other cases a <code class="computeroutput">std::bad_exception</code>
+ is thrown.
+ 
+<pre class="programlisting">boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+> pool( boost::tp::poolsize( 10) );
+
+// task will throw an exception derived from std::exception
+boost::tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn) ) );
+
+std::cout << t.result().get() << std::endl; // will rethrow an std::runtime_error
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Oliver Kowalke
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="pool.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="this_task.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/html/boost_threadpool/this_task.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/boost_threadpool/this_task.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,52 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Namespace this_task</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="prev" href="task.html" title="Task">
+<link rel="next" href="channel.html" title="Channel">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="task.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="channel.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.this_task"></a><a class="link" href="this_task.html" title="Namespace this_task"> Namespace this_task</a>
+</h2></div></div></div>
+
+ In the function <code class="computeroutput">boost::this_task::reschedule_until(
+ Pred const&)</code> allows to synchronize the task with other
+ asynchronous events without blocking the worker threads (bool Pred::operator()()
+ must not block) The current task will be rescheduled until the passed predicate
+ becomes true. The pool can be accessed via <code class="computeroutput">boost::this_task::get_thread_pool< Pool >()</code> if the calling code is executed by a
+ worker thread. <code class="computeroutput">boost::this_task::s_worker()</code>
+ evaluates true if the current thread is worker thread and <code class="computeroutput">boost::this_task::worker_id()</code> returns the thread id.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Oliver Kowalke
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="task.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="channel.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/html/index.html
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/html/index.html 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,129 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Chapter 1. Boost.Threadpool</title>
+<link rel="stylesheet" href="boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="index.html" title="Chapter 1. Boost.Threadpool">
+<link rel="next" href="boost_threadpool/pool.html" title="Pool">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="boost_threadpool/pool.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="chapter" lang="en">
+<div class="titlepage"><div>
+<div><h2 class="title">
+<a name="boost_threadpool"></a>Chapter 1. Boost.Threadpool</h2></div>
+<div><div class="author"><h3 class="author">
+Oliver Kowalke
+</h3></div></div>
+<div>Copyright © 2008 Oliver Kowalke</div>
+<div><div class="legalnotice">
+<a name="id358702"></a>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></div>
+</div></div>
+<div class="toc">
+Table of Contents
+<dl>
+<dt>Introduction</dt>
+<dt> Pool</dt>
+<dt> Task</dt>
+<dt> Namespace this_task</dt>
+<dt> Channel</dt>
+<dt> Scheduling</dt>
+<dt> Fork/Join</dt>
+<dt> Acknowledgements</dt>
+<dt> Reference</dt>
+<dd><dl>
+<dt> Class template pool</dt>
+<dt> Class template task</dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.reschedule_until"> Non-member
+ function <code class="computeroutput">reschedule_until()</code></a></dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.get_thread_pool"> Non-member
+ function <code class="computeroutput">get_thread_pool()</code></a></dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.is_worker"> Non-member function
+ <code class="computeroutput">is_worker()</code></a></dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.worker_id"> Non-member function
+ <code class="computeroutput">worker_id()</code></a></dt>
+<dt> Class poolsize</dt>
+<dt> Class scanns</dt>
+<dt> Class high_watermark</dt>
+<dt> Class low_watermark</dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.invalid_poolsize"> Class
+ <code class="computeroutput">invalid_poolsize</code></a></dt>
+<dt> Class invalid_scanns</dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.invalid_timeduration"> Class
+ <code class="computeroutput">invalid_timeduration</code></a></dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.invalid_watermark"> Class
+ <code class="computeroutput">invalid_watermark</code></a></dt>
+<dt> Class task_rejected</dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.has_priority"> Meta function
+ <code class="computeroutput">has_priority</code></a></dt>
+<dt><a href="boost_threadpool/reference.html#boost_threadpool.reference.priority_type"> Meta function
+ <code class="computeroutput">priority_type</code></a></dt>
+</dl></dd>
+</dl>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_threadpool.introduction"></a><a class="link" href="index.html#boost_threadpool.introduction" title="Introduction">Introduction</a>
+</h2></div></div></div>
+
+ Boost.Threadpool is designed for effectively
+ utilize the available hardware and provide a way for efficient asynchronous
+ processing of independent time consuming operations (actions) in the same process.
+ A thread pool contains a number of worker threads to perform actions in parallel,
+ which are usually managed by a scheduler. If a worker thread completes its
+ action, it will take the next action from the scheduler until all actions have
+ been completed. The worker thread then sleeps until there are new actions available.
+ Using a pool of worker threads over creating a new thread for each action may
+ result in better performance and better system stability because the overhead
+ for thread creation and destruction is negated.
+ 
+
+ Boost.Threadpool uses a <a class="link" href="boost_threadpool/pool.html#boost_threadpool.pool.work_stealing">work
+ stealing</a> algorithm and supports <a class="link" href="boost_threadpool/forkjoin.html" title="Fork/Join">fork/join</a>
+ parallelism (recursively splitting of actions into sub-actions that are solved
+ in parallel, waiting for them to complete, and then joining results).
+ 
+
+ In order to use the classes and functions described here, you can either include
+ the specific headers specified by the descriptions of each class or function,
+ or include the master library header:
+ 
+<pre class="programlisting">#include <boost/tp/tp.hpp>
+</pre>
+
+ which includes all the other headers in turn.
+ 
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ Boost.Threadpool uses a modified version
+ of the futures library, N2561 C++0x proposal, from Anthony Williams (http://www.justsoftwaresolutions.co.uk/threading/updated-implementation-of-c++-futures-3.html).
+ </td></tr>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left">Last revised: March 05, 2009 at 18:12:14 GMT</td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="boost_threadpool/pool.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
+</body>
+</html>

Added: sandbox/async/libs/tp/doc/introduction.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/introduction.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,24 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section Introduction]
+__boost_threadpool__ is designed for effectively utilize the available hardware and provide a way for efficient asynchronous processing of independent time consuming operations (__actions__) in the same process.
+A __threadpool__ contains a number of __worker_threads__ to perform __actions__ in parallel, which are usually managed by a scheduler. If a __worker_thread__ completes its __action__, it will take the next __action__ from the scheduler until all __actions__ have been completed. The __worker_thread__ then sleeps until there are new __actions__ available.
+Using a pool of __worker_threads__ over creating a new thread for each __action__ may result in better performance and better system stability because the overhead for thread creation and destruction is negated.
+
+__boost_threadpool__ uses a __work_stealing__ algorithm and supports __fork_join__ parallelism (recursively splitting of __actions__ into sub-actions that are solved in parallel, waiting for them to complete, and then joining results).
+
+In order to use the classes and functions described here, you can either include the specific headers specified by the descriptions of each class or function, or include the master library header:
+
+ #include <boost/tp/tp.hpp>
+
+which includes all the other headers in turn.
+
+[note
+__boost_threadpool__ uses a modified version of the futures library, N2561 C++0x proposal, from Anthony Williams ([@http://www.justsoftwaresolutions.co.uk/threading/updated-implementation-of-c++-futures-3.html]).]
+
+[endsect]

Added: sandbox/async/libs/tp/doc/meta_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/meta_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,36 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_priority Meta function `has_priority`]
+
+ #include <boost/tp/info.hpp>
+
+ template< typename Pool >
+ struct has_priority
+ :
+ public mpl::bool_<
+ is_same<
+ detail::has_priority,
+ typename Pool::scheduler_type::priority_tag_type
+ >::value
+ >
+ {};
+
+[endsect]
+
+
+[section:priority_type Meta function `priority_type`]
+
+ #include <boost/tp/info.hpp>
+
+ template< typename Pool >
+ struct priority_type
+ {
+ typedef typename Pool::scheduler_type::attribute_type type;
+ };
+
+[endsect]

Added: sandbox/async/libs/tp/doc/pool.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/pool.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,121 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:pool Pool]
+The pool manages internaly __worker_threads__ and submitted __actions__ are stored in a __channel__ (__global_queue__) for processing by the __worker_threads__ (using a __work_stealing__ algorithm). Each submitted __action__ gets associated with a __task__ object that will be returned. The __task__ object acts as a proxy for a result that is initially not known and gets evaluated later by a __worker_thread__.
+
+[heading Work-Stealing]
+Traditional thread poola do not scale because they use a single global queue protected by a global lock. The frequency at which __worker_threads__ aquire the global lock becomes a limiting factor for the throughput if:
+
+* the __actions__ become smaller
+* more processors are added
+
+A work-stealing algorithm can be used to solve this problem. It uses a special kind of queue which has two ends, and allows lock-free pushes and pops from the ['private end] (accessed by the __worker_thread__ owning the queue), but requires synchronization from the ['public end] (accessed by the other __worker_threads__). Synchronization is necessary when the queue is sufficiently small that private and public operations could conflict.
+
+The pool contains one global queue (__bounded_channel__ or __unbounded_channel__) protected by a global lock and each __worker_thread__ has its own private worker queue. If work is enqueued by a __worker_thread__ the __action__ is stored in the worker queue. If the work is enqueued by a application thread it goes into the global queue. When __worker_threads__ are looking for work, they have following search order:
+
+* look into the private worker queue - __actions__ can be dequeued without locks
+* look in the global queue - locks are used for synchronization
+* check other worker queues ('stealing' __actions__ from private worker queues of other __worker_threads__) - requires locks
+
+For a lot of recursively queued __actions__, the use of a worker queue per thread substantially reduces the synchronization necessary to complete the work. There are also fewer cache effects due to sharing of the global queue information.
+
+Operations on the private worker queue are executed in LIFO order and operations on worker queues of other __worker_threads__ in FIFO order (steals).
+
+* There are chances that memory is still hot in the cache, if the __actions__ are pushed in LIFO order into the private worker queue.
+* If a __worker_thread__ steals work in FIFO order, increases the chances that a larger 'chunk' of work will be stolen (the need for other steals will be possibly reduced). Because the __actions__ are stored in LIFO order, the oldest items are closer to the ['public end] of the queue (forming a tree). Stealing such an older __action__ also steals a (probably) larger subtree of __actions__ unfolded if the stolen work item get executed.
+
+[note __Actions__ submitted by a __worker_thread__ are stored into its private worker queue in LIFO order, thatswhy priorities and timeouts specified at the submit-function get ignored.]
+
+[important Because of the work-stealing algorithm the execution order of __actions__ may be not strict as in the global queue.]
+
+
+[heading Creation]
+The first template argument specifies the channel type and the scheduling policy.
+
+ boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+ > pool(
+ boost::tp::poolsize( 6),
+ boost::posix_time::posix_time::milliseconds( 50),
+ boost::tp::scanns(10) );
+
+In the example above a __threadpool__ is created with a __unbounded_channel__, scheduling __actions__ in ['FIFO] order. The pool contains six __worker_threads__ going to sleep for 50 millisec after 10 iterations without geting an __action__ from the __global_queue__, from its local __worker_queue__ or local queues of other __worker_threads__.
+
+ boost::tp::pool<
+ boost::tp::bounded_channel< boost::tp::priority < int > >
+ > pool(
+ boost::tp::poolsize( 10),
+ boost::tp::high_watermark( 10),
+ boost::tp::low_watermark( 5) );
+
+This pool uses a __bounded_channel__ which schedules __actions__ by integer atrributes. A maximum of 10 __actions__ can be queued in the __global_queue__ without blocking the inserting thread.
+
+
+[heading Shutdown]
+If `boost::tp::pool< Channel >::shutdown()` is called - the the status of the pool is set to ['terminating] and all __worker_threads__ are joined. No futher __actions__ can be submitted by application threads. After all pending __actions__ are processed and all __worker_threads__ are joined, the pool is set to status ['terminated].
+
+[note The deconstructor calls `boost::tp::pool< Channel >::shutdown()` if the pool was not shutdown yet.]
+
+ boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+ > pool( boost::tp::poolsize( 1) );
+
+ boost::tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ boost::tp::task< int > t2(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+
+ pool.shutdown();
+
+ std::cout << t1.result().get() << std::endl; // 55
+ std::cout << t2.result().get() << std::endl; // 55
+
+[heading Shutdown immediatly]
+The function `boost::tp::pool< Channel >::shutdown_now()` sets the pool status to ['terminating] interrupts and then joins all __worker_threads__. After the __worker_threads__ are joined the status of the pool is set to ['terminated] and all pending (unprocessed) __actions__ will be returned.
+
+[important Pending __actions__ in the local __worker_queues__ are not returned if `boost::tp::pool< Channel >::shutdown_now()` was called.]
+
+
+[heading Default pool]
+The free function `boost::tp::get_default_pool()` returns a reference to the default __threadpool__ instance. The default __threadpool__ is
+of type `boost::tp::pool< boost::tp::unbounded_channel< boost::tp::fifo > >` and will contain as many __worker_threads__ as
+`boost::thread::hardware_concurrency()` returns.
+
+
+[heading Meta functions]
+If the __threadpool__ supports priorities `boost::tp::has_priority< pool_type >` evaluates to `true`. The priority type is determined by `boost::tp::priority_type< pool_type >`.
+
+ typedef boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::priority< int > >
+ > pool_type;
+
+ std::cout << std::boolalpha << boost::tp::has_priority< pool_type >::value << std::endl;
+ std::cout << typeid( boost::tp::priority_type< pool_type >::type).name() << std::endl;
+
+The support of fibers can be tested with meta-function `boost::tp::has_fibers< pool_type >`.
+
+ std::cout << std::boolalpha << boost::tp::has_fibers< pool_type >::value << std::endl;
+
+[heading Processor binding]
+For some applications it is convenient to bind the worker threads of the pool to processors of the system. For this purpose BOOST_BIND_WORKER_TO_PROCESSORS must be defined. Without the poolsize in the construtor the __threadpool__ will contain as many
+__worker_threads__ as processors (== __hardware_concurrency__) are available and each __worker_thread__ is bound to one processor.
+
+ boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+ > pool;
+
+The code above will create a pool with two __worker_threads__ on a dual core system (each bound to one core).
+
+[endsect]
+

Added: sandbox/async/libs/tp/doc/pool_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/pool_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,349 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:pool Class template `pool`]
+
+ #include <boost/tp/pool.hpp>
+
+ template< typename Channel >
+ class pool
+ : private noncopyable
+ {
+ public:
+ explicit pool(
+ poolsize const& psize,
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) );
+
+ explicit pool(
+ poolsize const& psize,
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::milliseconds( 100),
+ scanns const& scns = scanns( 20) );
+
+
+ explicit pool(
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) );
+
+ explicit pool(
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::milliseconds( 100),
+ scanns const& scns = scanns( 20) );
+
+ ~pool();
+
+ std::size_t size();
+ std::size_t active();
+ std::size_t idle();
+
+ void shutdown();
+ const std::vector< callable > shutdown_now();
+
+ bool terminated();
+ bool terminateing();
+ void clear();
+ bool empty();
+ std::size_t pending();
+
+ const std::size_t upper_bound();
+ void upper_bound( high_watermark const& hwm);
+ const std::size_t lower_bound();
+ void lower_bound( low_watermark const& lwm);
+
+ template< typename Act >
+ task< typename result_of< Act() >::type > submit( Act const& act);
+
+ template< typename Act, typename Attr >
+ task< typename result_of< Act() >::type > submit(
+ Act const& act,
+ Attr const& attr);
+ };
+
+ pool< unbounded_channel< fifo > > & get_default_pool();
+
+[section:constructor_unbounded_channel_hw Constructor (unbounded channel)]
+
+ explicit pool(
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) );
+
+[variablelist
+[[Preconditions:] [Operating system provides functionality for processor pining.]]
+[[Effects:] [Constructs a `boost::tp::pool< Channel >` instance. For each processor a worker-thread is created and each worker-thread is pined exactly to one processor.]]
+[[Throws:] [`boost::tp::invalid_scanns`, `boost::tp::invalid_timeduration`]]
+[[Notes:] [Constructor has to be called if a __unbounded_channel__ is used.]]
+]
+[endsect]
+
+
+[section:constructor_unbounded_channel Constructor (unbounded channel)]
+
+ explicit pool(
+ poolsize const& psize,
+ posix_time::time_duration const& asleep = posix_time::microseconds( 10),
+ scanns const& scns = scanns( 20) );
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::pool< Channel >` instance. Pool contains psize worker-threads.]]
+[[Throws:] [`boost::tp::invalid_scanns`, `boost::tp::invalid_timeduration`]]
+[[Notes:] [Constructor has to be called if a __unbounded_channel__ is used.]]
+]
+[endsect]
+
+
+[section:constructor_bounded_channel_hw Constructor (bounded channel)]
+
+ explicit pool(
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::milliseconds( 100),
+ scanns const& scns = scanns( 20) );
+
+[variablelist
+[[Preconditions:] [Operating system provides functionality for processor pining.]]
+[[Effects:] [Constructs a `boost::tp::pool< Channel >` instance. For each processor a worker-thread is created and each worker-thread is pined exactly to one processor.]]
+[[Throws:] [`boost::tp::invalid_scanns`, `boost::tp::invalid_timeduration`, `boost::tp::invalid_watermark`]]
+[[Notes:] [Constructor has to be called if a __bounded_channel__ is used.]]
+]
+[endsect]
+
+
+[section:constructor_bounded_channel Constructor (bounded channel)]
+
+ explicit pool(
+ poolsize const& psize,
+ high_watermark const& hwm,
+ low_watermark const& lwm,
+ posix_time::time_duration const& asleep = posix_time::milliseconds( 100),
+ scanns const& scns = scanns( 20) );
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::pool< Channel >` instance. Pool contains psize worker-threads.]]
+[[Throws:] [`boost::tp::invalid_scanns`, `boost::tp::invalid_timeduration`, `boost::tp::invalid_watermark`]]
+[[Notes:] [Constructor has to be called if a __bounded_channel__ is used.]]
+]
+[endsect]
+
+
+[section:destructor Destructor]
+
+ ~pool();
+
+[variablelist
+[[Effects:] [Calls `boost::tp::pool< Channel >::shutdown()` if not yet called.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:size Member function `size()`]
+
+ std::size_t size();
+
+[variablelist
+[[Effects:] [Returns how many worker threads are running in the pool.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:active Member function `active()`]
+
+ std::size_t active();
+
+[variablelist
+[[Effects:] [Returns how many worker threads are active (executing an __action__).]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:idle Member function `idle()`]
+
+ std::size_t idle();
+
+[variablelist
+[[Effects:] [Returns how many worker threads are idle (not executing an __action__).]]
+[[Throws:] [Nothing]]
+[[Notes:] [The value is the difference of `size()` and `active()`]]
+]
+[endsect]
+
+
+[section:shutdown Member function `shutdown()`]
+
+ void shutdown();
+
+[variablelist
+[[Effects:] [Changes the pool state to ['terminating], deactivates the channel and joins all worker threads. The status of the pool is assigned to ['terminated] at the end.]]
+[[Throws:] [Nothing]]
+[[Notes:] [All pending __actions__ are processed.]]
+]
+[endsect]
+
+
+[section:shutdown_now Member function `shutdown_now()`]
+
+ const std::vector< callable > shutdown_now();
+
+[variablelist
+[[Effects:] [Changes the pool state to ['terminating], deactivates the channel, send interruption request to all worker threads and joins them. The status of the pool is assigned to ['terminated] at the end.]]
+[[Throws:] [Nothing]]
+[[Notes:] [Pending __actions__ are not processed but returned.]]
+]
+[endsect]
+
+
+[section:terminated Member function `terminated()`]
+
+ bool terminated();
+
+[variablelist
+[[Effects:] [Queries if the pool is in the terminated state (pool is shutdown).]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:terminateing Member function `terminateing()`]
+
+ bool terminateing();
+
+[variablelist
+[[Effects:] [Queries if the pool is in the terminating state (tries to shutdown the pool).]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:clear Member function `clear()`]
+
+ void clear();
+
+[variablelist
+[[Effects:] [Removes all pending __actions__ from the __channel__.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:empty Member function `empty()`]
+
+ bool empty();
+
+[variablelist
+[[Effects:] [Queries if the __channel__ is empty.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:pending Member function `pending()`]
+
+ std::size_t pending();
+
+[variablelist
+[[Effects:] [Queries how many __actions__ are pending in the __channel__.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:get_upper_bound Member function `upper_bound()`]
+
+ std::size_t upper_bound();
+
+[variablelist
+[[Preconditions:] [Channel is of type __bounded_channel__.]]
+[[Effects:] [Returns the upper bound of the __bounded_channel__.]]
+[[Throws:] [Nothing]]
+[[Notes:] [Can only be used if a __bounded_channel__ is used.]]
+]
+[endsect]
+
+
+[section:set_upper_bound Member function `upper_bound( high_watermark const& hwm)`]
+
+ void upper_bound( high_watermark const& hwm);
+
+[variablelist
+[[Preconditions:] [Channel is of type __bounded_channel__.]]
+[[Effects:] [Sets the upper bound of the __bounded_channel__.]]
+[[Postconditions:] [`this->upper_bound() == hwm`.]]
+[[Throws:] [`boost::tp::invalid_watermark`]]
+[[Notes:] [Can only be used if a __bounded_channel__ is used.]]
+]
+[endsect]
+
+
+[section:get_lower_bound Member function `lower_bound()`]
+
+ std::size_t lower_bound();
+
+[variablelist
+[[Preconditions:] [Channel is of type __bounded_channel__.]]
+[[Effects:] [Returns the lower bound of the __bounded_channel__.]]
+[[Throws:] [Nothing]]
+[[Notes:] [Can only be used if a __bounded_channel__ is used.]]
+]
+[endsect]
+
+
+[section:set_lower_bound Member function `lower_bound( low_watermark const& lwm)`]
+
+ void lower_bound( low_watermark const& lwm);
+
+[variablelist
+[[Preconditions:] [Channel is of type __bounded_channel__.]]
+[[Effects:] [Sets the lower bound of the __bounded_channel__.]]
+[[Postconditions:] [`this->lower_bound() == lwm`.]]
+[[Throws:] [`boost::tp::invalid_watermark`]]
+[[Notes:] [Can only be used if a __bounded_channel__ is used.]]
+]
+[endsect]
+
+
+[section:submit Member function `submit( Act const& act)`]
+
+ template< typename Act >
+ task< typename result_of< Act() >::type > submit( Act const& act);
+
+[variablelist
+[[Preconditions:] [has_priority< pool >::value == false && ! ( pool.terminating() || pool.terminated() )]]
+[[Effects:] [Submits an __action__ to the pool and returns a __task__ object.]]
+[[Throws:] [`boost::tp::task_rejected`]]
+]
+[endsect]
+
+
+[section:submit_attr Member function `submit( Act const& act, Attr const& attr)`]
+
+ template< typename Act, typename Attr >
+ task< typename result_of< Act() >::type > submit( Act const& act, Attr const& attr);
+
+[variablelist
+[[Preconditions:] [has_priority< pool >::value == true && ! ( pool.terminating() || pool.terminated() )]]
+[[Effects:] [Submits an __action__ to the pool and returns a __task__ object. __Action__ is scheduled by the attribute.]]
+[[Throws:] [`boost::tp::task_rejected`]]
+]
+[endsect]
+
+
+[section:get_default_pool Non-member function `get_default_pool()`]
+
+ pool< unbounded_channel< fifo > > & get_default_pool();
+
+[variablelist
+[[Effects:] [Get access to default thread pool (static).]]
+]
+[endsect]
+
+
+[endsect]

Added: sandbox/async/libs/tp/doc/poolsize_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/poolsize_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,43 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:poolsize Class `poolsize`]
+
+ #include <boost/tp/poolsize.hpp>
+
+ class poolsize
+ {
+ public:
+ explicit poolsize( std::size_t value);
+
+ operator std::size_t () const;
+ };
+
+[section:constructor Constructor]
+
+ explicit poolsize( std::size_t value);
+
+[variablelist
+[[Preconditions:][value > 0]]
+[[Effects:] [Constructs a `boost::tp::poolsize` instance.]]
+[[Postconditions:][operator std::size_t () > 0]]
+[[Throws:] [`boost::tp::invalid_poolsize`]]
+]
+[endsect]
+
+
+[section:operator Member function `operator std::size_t()`]
+
+ operator std::size_t () const;
+
+[variablelist
+[[Effects:] [Returns pool size.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]

Added: sandbox/async/libs/tp/doc/reference.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/reference.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,19 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:reference Reference]
+
+[include pool_ref.qbk]
+[include task_ref.qbk]
+[include this_task_ref.qbk]
+[include poolsize_ref.qbk]
+[include scanns_ref.qbk]
+[include watermark_ref.qbk]
+[include exceptions_ref.qbk]
+[include meta_ref.qbk]
+
+[endsect]

Added: sandbox/async/libs/tp/doc/scanns_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/scanns_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,42 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:scanns Class `scanns`]
+
+ #include <boost/tp/scanns.hpp>
+
+ class scanns
+ {
+ public:
+ explicit scanns( std::size_t value);
+
+ operator std::size_t () const;
+ };
+
+[section:constructor Constructor]
+
+ explicit scanns( std::size_t value);
+
+[variablelist
+[[Preconditions:][value >= 0]]
+[[Effects:] [Constructs a `boost::tp::scanns` instance.]]
+[[Postconditions:][operator std::size_t () >= 0]]
+[[Throws:] [`boost::tp::invalid_scanns`]]
+]
+[endsect]
+
+[section:operator Member function `operator std::size_t()`]
+
+ operator std::size_t () const;
+
+[variablelist
+[[Effects:] [Returns scanns size.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]

Added: sandbox/async/libs/tp/doc/scheduling.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/scheduling.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,84 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:scheduling Scheduling]
+The scheduling policy determines how __actions__ are scheduled inside the __channel__.
+
+[heading fifo]
+
+ struct fifo
+
+First inserted pending __action__ get taken first.
+
+
+[heading lifo]
+
+ struct lifo
+
+Last inserted pending __action__ get taken first.
+
+
+[heading priority]
+
+ template< typename Attr, typename Ord = std::less< Attr > > struct priority
+
+Each pending task is associated with a priority attribute which is used for ordering __actions__.
+
+
+[heading smart]
+
+ template< typename Attr, typename Ord, typename Enq, typename Deq > struct smart
+
+Each pending __actions__ is associated with an attribute. The scheduler gets an put- and take-policy
+as template arguments. The corresponding policy get applied for each insertion and removal.
+
+__boost_threadpool__ provides ['boost::tp::replace_oldest] as put policy and ['boost::tp::take_oldest] as take
+policy. Both policies allow the replacement of old __actions__ in the scheduler by new ones.
+
+ // creates a pool with unbounded channel
+ // tasks are processed depending on the associated attributed
+ // oldest tasks with the same attributed pending in the channel
+ // will be replaced by the new task
+ // this example would execute add( 1, 2) and add( 5, 6)
+ // add( 2, 3) is removed (if pending when add( 5, 6) is submitted)
+ boost::tp::pool<
+ boost::tp::unbounded_channel<
+ boost::tp::smart<
+ int,
+ std::less< int >,
+ boost::tp::replace_oldest,
+ boost::tp::take_oldest
+ >
+ >
+ > pool( boost::tp::poolsize( 1) );
+
+ pool.submit(
+ boost::bind(
+ add_fn,
+ 1,
+ 2),
+ 0);
+
+ // replaced by later task with same attribute
+ // if still pending in pool
+ pool.submit(
+ boost::bind(
+ add_fn,
+ 3,
+ 4),
+ 1);
+
+ // will replace previous pending action
+ pool.submit(
+ boost::bind(
+ add_fn,
+ 5,
+ 6),
+ 1);
+
+
+[endsect]

Added: sandbox/async/libs/tp/doc/stacksize_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/stacksize_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,42 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:stacksize Class `stacksize`]
+
+ #include <boost/tp/stacksize.hpp>
+
+ class stacksize
+ {
+ public:
+ explicit stacksize( std::size_t value);
+
+ operator std::size_t () const;
+ };
+
+[section:constructor Constructor]
+
+ explicit stacksize( std::size_t value);
+
+[variablelist
+[[Preconditions:][value > 0]]
+[[Effects:] [Constructs a `boost::tp::stacksize` instance.]]
+[[Postconditions:][operator std::size_t () > 0]]
+[[Throws:] [`boost::tp::invalid_stacksize`]]
+]
+[endsect]
+
+[section:operator Member function `operator std::size_t()`]
+
+ operator std::size_t () const;
+
+[variablelist
+[[Effects:] [Returns stack size.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]

Added: sandbox/async/libs/tp/doc/task.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/task.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,122 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:task Task]
+For each submitted __action__ a new task object will be created and returned by the pool.
+The __task__ object acts as a proxy for a result that is initially not known and gets evaluated later by a __worker_thread__. It transports the result (value or exception) of the __action__ back to the caller.
+
+ boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+ > pool( boost::tp::poolsize( 10) );
+
+ // task calculates fibonacci(10)
+ // scheduled in unbounded channel with FIFO ordering
+ boost::tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+
+ std::cout << t.result().get() << std::endl; // 55
+
+
+[heading Interruption]
+The returned __task__ object provides the possiblity to interrupt an __action__ if it is cooperative.
+An __action__ is known as cooperative if it includes interruption points in its code:
+
+* `boost::thread::join()`
+* `boost::thread::timed_join()`
+* `boost::condition_variable::wait()`
+* `boost::condition_variable::timed_wait()`
+* `boost::condition_variable_any::wait()`
+* `boost::condition_variable_any::timed_wait()`
+* `boost::thread::sleep()`
+* `boost::this_thread::sleep()`
+* `boost::this_thread::interruption_point()`
+
+[important Interruption must not be disabled for the __worker_thread__ (class ['boost::this_thread::disable_interruption]).]
+
+The __action__ will be interrupted even if it is pending (interruption is remembered).
+A ['boost::thread_interrupted] exception will be thrown by `boost::tp::task< T >::get()` if the __action__ was interrupted.
+``
+ boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+ > pool( boost::tp::poolsize( 10) );
+
+ // submit a long running task
+ boost::tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ long_running_fn) ) );
+
+ // interrupt task
+ t.interrupt();
+
+ // throws boost::thread_interrupted exception
+ std::cout << t.result().get() << std::endl;
+``
+
+ boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+ > pool( boost::tp::poolsize( 10) );
+
+ // submit a long running task
+ boost::tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ long_running_fn) ) );
+
+ // interrupt task and wait for its termination
+ t.interrupt_and_wait();
+
+ // throws boost::thread_interrupted exception
+ std::cout << t.result().get() << std::endl;
+
+[heading Exceptions in tasks]
+Exceptions thrown inside an __action__ are transported by the associated task object.
+Exceptions rethrown by type:
+
+* `std::bad_alloc`
+* `std::bad_cast`
+* `std::bad_exception`
+* `std::bad_typeid`
+* `std::domain_error`
+* `std::invalid_argument`
+* `std::ios_base::failure`
+* `std::length_error`
+* `std::logic_error`
+* `std::out_of_range`
+* `std::overflow_error`
+* `std::range_error`
+* `std::runtime_error`
+* `std::underflow_error`
+* `boost::broken_promise`
+* `boost::future_already_set`
+* `boost::future_cancel`
+* `boost::invalid_thread_argument`
+* `boost::lock_error`
+* `boost::thread_exception`
+* `boost::thread_interrupted`
+* `boost::thread_permission_error`
+* `boost::thread_resource_error`
+* `boost::unsupported_thread_option`
+
+Exceptions derived from `std::exception` will be rethrown as `std::runtime_error` in all other cases a `std::bad_exception` is thrown.
+
+ boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+ > pool( boost::tp::poolsize( 10) );
+
+ // task will throw an exception derived from std::exception
+ boost::tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn) ) );
+
+ std::cout << t.result().get() << std::endl; // will rethrow an std::runtime_error
+
+[endsect]

Added: sandbox/async/libs/tp/doc/task_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/task_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,86 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:task Class template `task`]
+
+ #include <boost/tp/task.hpp>
+
+ template< typename R >
+ class task
+ {
+ public:
+ template< typename Pool >
+ task(
+ Pool * pool,
+ shared_future< R > const& fut,
+ detail::interrupter const& intr);
+
+ void interrupt();
+ void interrupt_and_wait();
+ void interrupt_and_wait( system_time const& abs_time);
+ template< typename Duration >
+ void interrupt_and_wait( Duration const& rel_time);
+ bool interrupt_requested();
+
+ shared_future< R > result() const;
+ };
+
+[section:constructor Constructor]
+
+ template< typename Pool >
+ task(
+ Pool * pool,
+ shared_future< R > const& fut,
+ detail::interrupter const& intr);
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::task< R >` instance.]]
+[[Throws:] [Nothing]]
+[[Notes:] [task objects should only be constructed by the pool.]]
+]
+[endsect]
+
+
+[section:interrupt Member function `interrupt()`]
+
+ void interrupt();
+
+[variablelist
+[[Effects:] [Associated __action__ will be interrupted the next time it enters a __interruption_point__ if interruption is not disabled. The function returns immediatly.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:interrupt_and_wait Member function `interrupt_and_wait()`]
+
+ void interrupt_and_wait();
+
+ void interrupt_and_wait( system_time const& abs_time);
+
+ template< typename DurationTime >
+ void interrupt_and_wait( DurationTime const& rel_time);
+
+[variablelist
+[[Effects:] [Associated __action__ will be interrupted the next time it enters one __interruption_point__ if interruption is not disabled. The function waits until the __action__ has terminated or the specified duration td has elapsed.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+
+[section:result Member function `result()`]
+
+ shared_future< R > result() const;
+
+[variablelist
+[[Effects:] [Returns fulfilled value or throws fulfilled exception via a shared_future.]]
+[[Throws:] [`boost::future::broken_promise`]]
+]
+[endsect]
+
+
+[endsect]

Added: sandbox/async/libs/tp/doc/this_task.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/this_task.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,16 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:this_task Namespace this_task]
+In the function `boost::this_task::reschedule_until( Pred const&)` allows to synchronize the task with other
+asynchronous events without blocking the __worker_threads__ (bool Pred::operator()() must not block)
+The current task will be rescheduled until the passed predicate becomes true.
+The pool can be accessed via `boost::this_task::get_thread_pool< Pool >()` if the calling code is executed by a __worker_thread__.
+`boost::this_task::s_worker()` evaluates true if the current thread is __worker_thread__ and `boost::this_task::worker_id()`
+returns the thread id.
+
+[endsect]

Added: sandbox/async/libs/tp/doc/this_task_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/this_task_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,64 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:reschedule_until Non-member function `reschedule_until()`]
+
+ #include <boost/tp/pool.hpp>
+
+ template< typename Pred >
+ void reschedule_until( Pred const&);
+
+[variablelist
+[[Effects:] [Reschedules current task until passed callable predicate becomes ready.]
+[[Throws:] [Nothing.]]
+[[Note:] [This function resides in namespace `boost::this_task`.]]
+]
+
+[endsect]
+
+[section:get_thread_pool Non-member function `get_thread_pool()`]
+
+ #include <boost/tp/pool.hpp>
+
+ template< typename Pool >
+ Pool & get_thread_pool();
+
+[variablelist
+[[Effects:] [Returns reference to the thread pool where the current worker thread is running.]
+[[Throws:] [Nothing.]]
+[[Note:] [This function resides in namespace `boost::this_task`.]]
+]
+
+[endsect]
+
+[section:is_worker Non-member function `is_worker()`]
+
+ #include <boost/tp/pool.hpp>
+
+ bool is_worker();
+
+[variablelist
+[[Effects:] [Returns true if the current thread is a worker-thread form a pool.]
+[[Throws:] [Nothing.]]
+[[Note:] [This function resides in namespace `boost::this_task`.]]
+]
+
+[endsect]
+
+[section:worker_id Non-member function `worker_id()`]
+
+ #include <boost/tp/pool.hpp>
+
+ thread::id worker_id();
+
+[variablelist
+[[Effects:] [Returns returns the thread-id of the worker-thread.]
+[[Throws:] [Nothing.]]
+[[Note:] [This function resides in namespace `boost::this_task`.]]
+]
+
+[endsect]

Added: sandbox/async/libs/tp/doc/threadpool.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/threadpool.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,59 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[library Boost.Threadpool
+ [quickbook 1.4]
+ [copyright 2008 Oliver Kowalke]
+ [purpose C++ Library for executing actions in a pool of worker threads]
+ [license
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ [@http://www.boost.org/LICENSE_1_0.txt])
+ ]
+ [authors [Kowalke, Oliver]]
+ [category text]
+]
+
+
+[def __action__ action]
+[def __actions__ actions]
+[def __Actions__ Actions]
+[def __boost__ [*boost-1.37.0]]
+[def __boost_future__ [*Boost.Future]]
+[def __boost_threadpool__ [*Boost.Threadpool]]
+[def __bounded_channel__ [link boost_threadpool.channel.bounded_channel ['bounded channel]]]
+[def __unbounded_channel__ [link boost_threadpool.channel.unbounded_channel ['unbounded channel]]]
+[def __channel__ [link boost_threadpool.channel ['channel]]]
+[def __channels__ [link boost_threadpool.channel ['channels]]]
+[def __fork_join__ [link boost_threadpool.forkjoin ['fork/join]]]
+[def __global_queue__ [link boost_threadpool.pool.work_stealing ['global queue]]]
+[def __hardware_concurrency__ boost::thread::hardware_concurrency]
+[def __hwm__ high watermark]
+[def __interruption_point__ [link boost_threadpool.task.interruption ['interruption point]]]
+[def __lwm__ low watermark]
+[def __scheduler_type__ [link boost_threadpool.scheduling ['scheduler type]]]
+[def __sub_action__ sub_action]
+[def __sub_actions__ sub_actions]
+[def __task__ [link boost_threadpool.task ['task]]]
+[def __tasks__ [link boost_threadpool.task ['tasks]]]
+[def __threadpool__ thread pool]
+[def __work_stealing__ [link boost_threadpool.pool.work_stealing ['work stealing]]]
+[def __worker_queue__ [link boost_threadpool.pool.work_stealing ['worker queue]]]
+[def __worker_queues__ [link boost_threadpool.pool.work_stealing ['worker queues]]]
+[def __worker_thread__ worker thread]
+[def __worker_threads__ worker threads]
+
+
+[include introduction.qbk]
+[include pool.qbk]
+[include task.qbk]
+[include this_task.qbk]
+[include channel.qbk]
+[include scheduling.qbk]
+[include forkjoin.qbk]
+[include acknowledgement.qbk]
+[include reference.qbk]

Added: sandbox/async/libs/tp/doc/watermark_ref.qbk
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/doc/watermark_ref.qbk 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,75 @@
+[/
+ (C) Copyright 2008 Oliver Kowalke.
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:high_watermark Class `high_watermark`]
+
+ #include <boost/tp/watermark.hpp>
+
+ class high_watermark
+ {
+ public:
+ explicit high_watermark( std::size_t value);
+
+ operator std::size_t () const;
+ };
+
+[section:constructor Constructor]
+
+ explicit high_watermark( std::size_t value);
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::high_watermark` instance.]]
+[[Throws:] [`boost::tp::invalid_watermark`]]
+]
+[endsect]
+
+[section:operator Member function `operator std::size_t()`]
+
+ operator std::size_t () const;
+
+[variablelist
+[[Effects:] [Returns high watermark.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]
+
+
+[section:low_watermark Class `low_watermark`]
+
+ #include <boost/tp/watermark.hpp>
+
+ class low_watermark
+ {
+ public:
+ explicit low_watermark( std::size_t value);
+
+ operator std::size_t () const;
+ };
+
+[section:constructor Constructor]
+
+ explicit low_watermark( std::size_t value);
+
+[variablelist
+[[Effects:] [Constructs a `boost::tp::low_watermark` instance.]]
+[[Throws:] [`boost::tp::invalid_watermark`]]
+]
+[endsect]
+
+[section:operator Member function `operator std::size_t()`]
+
+ operator std::size_t () const;
+
+[variablelist
+[[Effects:] [Returns low watermark.]]
+[[Throws:] [Nothing]]
+]
+[endsect]
+
+[endsect]
\ No newline at end of file

Added: sandbox/async/libs/tp/examples/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/Jamfile.v2 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,26 @@
+# Boost.ThreadPool Library Example Jamfile
+
+# Copyright (C) 2008 Oliver Kowalke
+
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# For more information, see http://www.boost.org/
+
+project boost/tp/example
+ : requirements
+ <library>../../thread/build//boost_thread
+ <library>../../system/build//boost_system
+ <threading>multi
+ ;
+
+exe chained_submit : chained_submit.cpp ;
+exe interrupt : interrupt.cpp ;
+exe lazy_submit : lazy_submit.cpp ;
+exe pending : pending.cpp ;
+exe priority : priority.cpp ;
+exe fork_join : fork_join.cpp ;
+exe shutdonw_now : shutdonw_now.cpp ;
+exe smart : smart.cpp ;
+exe submit : submit.cpp ;
\ No newline at end of file

Added: sandbox/async/libs/tp/examples/fork_join.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/fork_join.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,101 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include "boost/tp/fifo.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+typedef tp::pool< tp::unbounded_channel< tp::fifo > > pool_type;
+
+class fibo
+{
+private:
+ int offset_;
+
+ int seq_( int n)
+ {
+ if ( n <= 1) return n;
+ else return seq_( n - 2) + seq_( n - 1);
+ }
+
+ int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 1) ) );
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 2) ) );
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 3) );
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/examples/interrupt.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/interrupt.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,69 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include "boost/tp/fifo.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+inline
+int fibonacci_fn( int n)
+{
+ if ( n == 0) return 0;
+ if ( n == 1) return 1;
+ int k1( 1), k2( 0);
+ for ( int i( 2); i <= n; ++i)
+ {
+ boost::this_thread::interruption_point();
+ int tmp( k1);
+ k1 = k1 + k2;
+ k2 = tmp;
+ }
+ boost::this_thread::interruption_point();
+ return k1;
+}
+
+inline
+void long_running_fn()
+{ boost::this_thread::sleep( pt::seconds( 1) ); }
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ pool.submit(
+ boost::bind(
+ long_running_fn) );
+ std::cout << "poolsize == " << pool.size() << std::endl;
+ std::cout << "idle threads == " << pool.idle() << std::endl;
+ std::cout << "active threads == " << pool.active() << std::endl;
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ t.interrupt();
+ std::cout << t.result().get() << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( boost::thread_interrupted const& )
+ { std::cerr << "thread_interrupted: task was canceled" << std::endl; }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/examples/parallel_sort.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/parallel_sort.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,273 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interthreads for documentation.
+//
+// Based on the shared.cpp example from the threadalert library of Roland Schwarz
+//////////////////////////////////////////////////////////////////////////////
+
+// requires interthread and range available at boost-sandbox and boost-vault
+
+#include <iostream>
+#include <algorithm>
+
+#include <boost/progress.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/bind.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/unbounded_channel.hpp>
+#include <boost/tp/fifo.hpp>
+#include <boost/range/algorithm/sort.hpp>
+#include <boost/range/algorithm/inplace_merge.hpp>
+#include <boost/range/sub_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/algorithm/equal.hpp>
+#include <boost/range/algorithm/for_each.hpp>
+#include <boost/range/algorithm/transform.hpp>
+#include <boost/range/adaptor/sliced.hpp>
+#include <boost/interthreads/fork.hpp>
+#include <boost/interthreads/algorithm/wait.hpp>
+#include <boost/interthreads/scheduler.hpp>
+#include <boost/array.hpp>
+
+#include <assert.h>
+
+#define BOOST_PARTS 2
+#define NN 10000000
+
+class scoped_timer {
+ boost::posix_time::ptime start_;
+public:
+ scoped_timer()
+ : start_(boost::posix_time::microsec_clock::universal_time())
+ {}
+ ~scoped_timer() {
+ boost::posix_time::ptime stop( boost::posix_time::microsec_clock::universal_time() );
+ std::cout << " " << ( stop - start_).total_milliseconds() << " milli seconds" << std::endl;
+ }
+};
+
+template <typename Range>
+class partition
+{
+public:
+ boost::iterator_range<typename boost::range_iterator<Range>::type> range_;
+ std::size_t parts_;
+ partition(boost::iterator_range<typename boost::range_iterator<Range>::type>& range, std::size_t parts):
+ range_(range),
+ parts_(parts)
+ {}
+ boost::iterator_range<typename boost::range_iterator<Range>::type> operator[](unsigned i) {
+ unsigned size = boost::size(range_);
+ if (i<(parts_-1))
+ return boost::make_sliced_range(range_, i*(size/parts_), ((i+1)*(size/parts_)));
+ else
+ return boost::make_sliced_range(range_, (parts_-1)*(size/parts_), size);
+ }
+};
+
+typedef boost::tp::pool<
+ boost::tp::unbounded_channel< boost::tp::fifo >
+> pool_type;
+
+#ifdef TASK_POOL
+ typedef boost::tp::task< pool_type, void > task_type;
+#else
+ typedef boost::tp::task< void > task_type;
+#endif
+
+
+template <
+ typename DirectSolver,
+ typename Composer,
+ typename AE,
+ typename Range
+>
+ void inplace_solve( AE & ae,
+ boost::iterator_range<typename boost::range_iterator<Range>::type> range,
+ unsigned cutoff );
+
+template <
+ typename DirectSolver,
+ typename Composer,
+ typename AE,
+ typename Range
+>
+ void inplace_solve( AE & ae,
+ boost::iterator_range<typename boost::range_iterator<Range>::type> range,
+ unsigned cutoff )
+ {
+ unsigned size = boost::size(range);
+ //std::cout << "<<par_ " << size;
+ if ( size <= cutoff) DirectSolver()(range);
+ else {
+ partition<Range> parts(range, BOOST_PARTS);
+ std::list<task_type> tasks;
+ #if 0 // this code do not compiles with gcc 3.4.4 cygwin
+ boost::transform(parts, boost::begin(tasks),
+ boost::bind(&AE::submit, boost::ref(ae),
+ //boost::bind(&boost::interthreads::fork<AE>, boost::ref(ae),
+ boost::bind(&inplace_solve<DirectSolver,Composer,AE,Range>, boost::ref(ae),_1,cutoff)));
+ #else
+ for (unsigned i=0;i < BOOST_PARTS-1; ++i) {
+ task_type tmp(ae.submit(
+ boost::bind(
+ &inplace_solve<DirectSolver,Composer,AE,Range>,
+ boost::ref(ae),
+ parts[i],
+ cutoff
+ )));
+ tasks.push_back(tmp);
+ }
+ #endif
+ inplace_solve<DirectSolver,Composer,AE,Range>(ae, parts[BOOST_PARTS-1], cutoff);
+ boost::for_each(tasks, &boost::interthreads::wait_act<task_type>);
+
+ //std::cout << "par_inplace_merge_fct " << size << ">>"<< std::endl;
+ Composer()(range);
+ //std::cout << "par_ " << size << ">>"<< std::endl;
+
+ }
+ }
+
+struct sort_fct {
+ template<class RandomAccessRange>
+ RandomAccessRange& operator()(RandomAccessRange rng) {
+ return boost::sort(rng);
+ }
+};
+
+struct inplace_merge_fct {
+ template<class BidirectionalRange>
+ BidirectionalRange&
+ operator()( BidirectionalRange rng) {
+ return boost::inplace_merge(rng, boost::begin(rng)+(boost::size(rng)/2));
+ }
+};
+template <typename AE, typename Range>
+void parallel_sort(AE& ae, Range& range, unsigned cutoff=10000) {
+ boost::iterator_range<typename boost::range_iterator<Range>::type> rng(range);
+ inplace_solve<sort_fct,inplace_merge_fct,pool_type,Range>( ae, rng, cutoff);
+}
+
+int sorted[NN];
+int values1[NN];
+int values2[NN];
+int values3[NN];
+int values4[NN];
+int values5[NN];
+int values6[NN];
+
+int main() {
+ for (unsigned i=0; i<NN; ++i) sorted[i]=i;
+
+ for (unsigned i=0; i<NN; ++i) values1[i]=NN-i-1;
+ {
+ std::cout << "std::sort: reverse 0.." << NN;
+ scoped_timer t; // start timing
+ std::sort(boost::begin(values1), boost::end(values1));
+ }
+ assert(boost::equal(values1, sorted));
+ {
+ std::cout << "std::sort: 0.." << NN;
+ scoped_timer t; // start timing
+ std::sort(boost::begin(values1), boost::end(values1));
+ }
+
+ for (unsigned i=0; i<NN; ++i) values2[i]=NN-i-1;
+ {
+ std::cout << "boost::sort: reverse 0.."<<NN;
+ scoped_timer t; // start timing
+ boost::sort(values2);
+ }
+ assert(boost::equal(values2, sorted));
+ {
+ std::cout << "boost::sort: 0.."<<NN;
+ scoped_timer t; // start timing
+ boost::sort(values2);
+ }
+
+ // creates a threadpool with two worker-threads
+ pool_type pool( boost::tp::poolsize( 2) );
+
+// // creates a threadpool with as many worker-threads
+// // as CPUs/Cores are online and bind each worker-thread
+// // to a specific CPU/Core
+// // requires BOOST_BIND_WORKER_TO_PROCESSORS to be specified
+// pool_type pool;
+
+ for (unsigned i=0; i<NN; ++i) values5[i]=NN-i-1;
+ {
+ std::cout << "parallel_sort "<<NN/2<<": reverse 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/2);
+ }
+ assert(boost::equal(values5, sorted));
+ {
+ std::cout << "parallel_sort "<<NN/2<<": 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/2);
+ }
+
+ for (unsigned i=0; i<NN; ++i) values5[i]=NN-i-1;
+ {
+ std::cout << "parallel_sort "<<NN/4<<": reverse 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/4);
+ }
+ assert(boost::equal(values5, sorted));
+ {
+ std::cout << "parallel_sort "<<NN/4<<": 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/4);
+ }
+
+ for (unsigned i=0; i<NN; ++i) values5[i]=NN-i-1;
+ {
+ std::cout << "parallel_sort "<<NN/8<<": reverse 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/8);
+ }
+ assert(boost::equal(values5, sorted));
+ {
+ std::cout << "parallel_sort "<<NN/8<<": 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/8);
+ }
+
+ for (unsigned i=0; i<NN; ++i) values5[i]=NN-i-1;
+ {
+ std::cout << "parallel_sort "<<NN/16<<": reverse 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/16);
+ }
+ assert(boost::equal(values5, sorted));
+ {
+ std::cout << "parallel_sort "<<NN/16<<": 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/16);
+ }
+
+ for (unsigned i=0; i<NN; ++i) values5[i]=NN-i-1;
+ {
+ std::cout << "parallel_sort "<<NN/32<<": reverse 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/32);
+ }
+ assert(boost::equal(values5, sorted));
+ {
+ std::cout << "parallel_sort "<<NN/32<<": 0.."<<NN;
+ scoped_timer tmr; // start timing
+ parallel_sort(pool, values5, NN/32);
+ }
+
+
+ std::cout << "shutdown"<< std::endl;
+ pool.shutdown();
+ std::cout << "end"<< std::endl;
+ return 0;
+}

Added: sandbox/async/libs/tp/examples/pending.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/pending.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,65 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/ref.hpp>
+
+#include "boost/tp/fifo.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+inline
+int fibonacci_fn( int n)
+{
+ if ( n == 0) return 0;
+ if ( n == 1) return 1;
+ int k1( 1), k2( 0);
+ for ( int i( 2); i <= n; ++i)
+ {
+ boost::this_thread::interruption_point();
+ int tmp( k1);
+ k1 = k1 + k2;
+ k2 = tmp;
+ }
+ boost::this_thread::interruption_point();
+ return k1;
+}
+
+inline
+void long_running_fn()
+{ boost::this_thread::sleep( pt::seconds( 1) ); }
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ pool.submit(
+ boost::bind(
+ long_running_fn) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ std::cout << "pending tasks == " << pool.pending() << std::endl;
+ std::cout << t.result().get() << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/examples/priority.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/priority.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,60 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+#include <string>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include "boost/tp/priority.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+inline
+void print_fn( std::string const& msg)
+{ printf("%s", msg.c_str() ); }
+
+inline
+void long_running_fn()
+{ boost::this_thread::sleep( pt::milliseconds( 250) ); }
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool( tp::poolsize( 1) );
+ pool.submit(
+ boost::bind(
+ long_running_fn),
+ 0);
+ pool.submit(
+ boost::bind(
+ print_fn,
+ "This"),
+ 0);
+ pool.submit(
+ boost::bind(
+ print_fn,
+ "a text.\n"),
+ 2);
+ pool.submit(
+ boost::bind(
+ print_fn,
+ " is "),
+ 1);
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/examples/reschedule_until.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/reschedule_until.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,136 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/interprocess/sync/interprocess_semaphore.hpp>
+#include <boost/thread.hpp>
+
+#include "boost/tp/fifo.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+typedef tp::pool< tp::unbounded_channel< tp::fifo > > pool_type;
+
+class fibo
+{
+private:
+ boost::shared_future< void > f_;
+ int offset_;
+
+ class holder
+ {
+ private:
+ boost::shared_future< void > f_;
+
+ public:
+ holder( boost::shared_future< void > const& f)
+ : f_( f)
+ {}
+
+ bool operator()()
+ { return f_.is_ready(); }
+ };
+
+ int seq_( int n)
+ {
+ if ( n <= 1) return n;
+ else return seq_( n - 2) + seq_( n - 1);
+ }
+
+ int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ if ( n == 7)
+ {
+ holder hldr( f_);
+ boost::this_task::reschedule_until( hldr);
+ }
+
+ boost::function< int() > fn1 = boost::bind(
+ & fibo::par_,
+ * this,
+ n - 1);
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ fn1) );
+ boost::function< int() > fn2 = boost::bind(
+ & fibo::par_,
+ * this,
+ n - 2);
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ fn2) );
+
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+public:
+ fibo(
+ boost::shared_future< void > f,
+ int offset)
+ : f_( f), offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+void f() {}
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ pool_type pool( tp::poolsize( 1) );
+ boost::packaged_task< void > tsk( boost::bind( f) );
+ boost::shared_future< void > f( tsk.get_future() );
+ fibo fib( f, 3);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 10; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ ::sleep( 1);
+ tsk();
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/examples/shutdonw_now.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/shutdonw_now.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,62 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/ref.hpp>
+
+#include "boost/tp/fifo.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+inline
+int fibonacci_fn( int n)
+{
+ boost::this_thread::sleep( pt::milliseconds( 500) );
+ if ( n == 0) return 0;
+ if ( n == 1) return 1;
+ int k1( 1), k2( 0);
+ for ( int i( 2); i <= n; ++i)
+ {
+ boost::this_thread::interruption_point();
+ int tmp( k1);
+ k1 = k1 + k2;
+ k2 = tmp;
+ }
+ boost::this_thread::interruption_point();
+ return k1;
+}
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ boost::this_thread::sleep( pt::milliseconds( 250) );
+ pool.shutdown_now();
+ std::cout << t.result().get() << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( boost::thread_interrupted const& )
+ { std::cerr << "thread_interrupted: thread was interrupted" << std::endl; }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/examples/smart.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/smart.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,86 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+#include <string>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include "boost/tp/smart.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+inline
+void fibonacci_fn( int n)
+{
+ if ( n == 0)
+ {
+ printf("fibonacci(%d) == 0\n", n);
+ return;
+ }
+ if ( n == 1)
+ {
+ printf("fibonacci(%d) == 1\n", n);
+ return;
+ }
+ int k1( 1), k2( 0);
+ for ( int i( 2); i <= n; ++i)
+ {
+ int tmp( k1);
+ k1 = k1 + k2;
+ k2 = tmp;
+ }
+ printf("fibonacci(%d) == %d\n", n, k1);
+}
+
+inline
+void long_running_fn()
+{ boost::this_thread::sleep( pt::milliseconds( 500) ); }
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ tp::pool<
+ tp::unbounded_channel<
+ tp::smart<
+ int,
+ std::less< int >,
+ tp::replace_oldest,
+ tp::take_oldest
+ >
+ >
+ > pool( tp::poolsize( 1) );
+ pool.submit(
+ boost::bind(
+ long_running_fn),
+ 0);
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 0),
+ 1);
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 1),
+ 2);
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 2);
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/examples/spread_over_hardware.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/spread_over_hardware.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,102 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include "boost/tp/fifo.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+typedef tp::pool< tp::unbounded_channel< tp::fifo > > pool_type;
+
+class fibo
+{
+private:
+ int offset_;
+
+ int seq_( int n)
+ {
+ if ( n <= 1) return n;
+ else return seq_( n - 2) + seq_( n - 1);
+ }
+
+ int par_( int n)
+ {
+ if ( n <= offset_) return seq_( n);
+ else
+ {
+ tp::task< int > t1(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 1) ) );
+ tp::task< int > t2(
+ boost::this_task::get_thread_pool< pool_type >().submit(
+ boost::bind(
+ & fibo::par_,
+ boost::ref( * this),
+ n - 2) ) );
+ return t1.result().get() + t2.result().get();
+ }
+ }
+
+public:
+ fibo( int offset)
+ : offset_( offset)
+ {}
+
+ int execute( int n)
+ {
+ int result( par_( n) );
+ return result;
+ }
+};
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ // ! BOOST_BIND_WORKER_TO_PROCESSORS must be defined !
+ pool_type pool;
+ fibo fib( 5);
+ std::vector< tp::task< int > > results;
+ results.reserve( 40);
+
+ pt::ptime start( pt::microsec_clock::universal_time() );
+
+ for ( int i = 0; i < 32; ++i)
+ results.push_back(
+ pool.submit(
+ boost::bind(
+ & fibo::execute,
+ boost::ref( fib),
+ i) ) );
+
+ int k = 0;
+ std::vector< tp::task< int > >::iterator e( results.end() );
+ for (
+ std::vector< tp::task< int > >::iterator i( results.begin() );
+ i != e;
+ ++i)
+ std::cout << "fibonacci " << k++ << " == " << i->result().get() << std::endl;
+
+ pt::ptime stop( pt::microsec_clock::universal_time() );
+ std::cout << ( stop - start).total_milliseconds() << " milli seconds" << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/examples/submit.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/examples/submit.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,53 @@
+#include <iostream>
+#include <cstdlib>
+#include <stdexcept>
+
+#include <boost/bind.hpp>
+
+#include "boost/tp/fifo.hpp"
+#include "boost/tp/pool.hpp"
+#include "boost/tp/poolsize.hpp"
+#include "boost/tp/unbounded_channel.hpp"
+
+namespace tp = boost::tp;
+
+inline
+int fibonacci_fn( int n)
+{
+ if ( n == 0) return 0;
+ if ( n == 1) return 1;
+ int k1( 1), k2( 0);
+ for ( int i( 2); i <= n; ++i)
+ {
+ boost::this_thread::interruption_point();
+ int tmp( k1);
+ k1 = k1 + k2;
+ k2 = tmp;
+ }
+ boost::this_thread::interruption_point();
+ return k1;
+}
+
+int main( int argc, char *argv[])
+{
+ try
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ std::cout << t.result().get() << std::endl;
+
+ return EXIT_SUCCESS;
+ }
+ catch ( std::exception const& e)
+ { std::cerr << "exception: " << e.what() << std::endl; }
+ catch ( ... )
+ { std::cerr << "unhandled" << std::endl; }
+
+ return EXIT_FAILURE;
+}

Added: sandbox/async/libs/tp/src/callable.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/src/callable.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,22 @@
+#include "boost/tp/detail/callable.hpp"
+
+namespace boost { namespace tp {
+namespace detail
+{
+callable::callable()
+: impl_()
+{}
+
+void
+callable::operator()()
+{ impl_->run(); }
+
+bool
+callable::empty() const
+{ return ! impl_; }
+
+void
+callable::clear()
+{ impl_.reset(); }
+} } }
+

Added: sandbox/async/libs/tp/src/default_pool.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/src/default_pool.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,10 @@
+#include "boost/tp/default_pool.hpp"
+#include <boost/thread.hpp>
+
+namespace boost { namespace tp {
+namespace detail
+{
+default_pool
+static_pool::instance( poolsize( thread::hardware_concurrency() ) );
+}
+} }

Added: sandbox/async/libs/tp/src/guard.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/src/guard.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,19 @@
+#include "boost/tp/detail/guard.hpp"
+
+namespace boost { namespace tp {
+namespace detail
+{
+guard::guard( volatile uint32_t & active_worker)
+: active_worker_( active_worker)
+{
+ BOOST_ASSERT( active_worker_ >= 0);
+ interprocess::detail::atomic_inc32( & active_worker_);
+}
+
+guard::~guard()
+{
+ interprocess::detail::atomic_dec32( & active_worker_);
+ BOOST_ASSERT( active_worker_ >= 0);
+}
+} } }
+

Added: sandbox/async/libs/tp/src/interrupter.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/src/interrupter.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,107 @@
+#include "boost/tp/detail/interrupter.hpp"
+
+namespace boost { namespace tp {
+namespace detail
+{
+void
+interrupter::impl::interrupt_()
+{
+ if ( ! interruption_requested_)
+ {
+ interruption_requested_ = true;
+ if ( thrd_) thrd_->interrupt();
+ }
+}
+
+interrupter::impl::impl()
+:
+interruption_requested_( false),
+cond_(),
+mtx_(),
+thrd_()
+{}
+
+void
+interrupter::impl::set( shared_ptr< thread > const& thrd)
+{
+ BOOST_ASSERT( thrd);
+ unique_lock< mutex > lk( mtx_);
+ thrd_ = thrd;
+ BOOST_ASSERT( thrd_);
+ if ( interruption_requested_) thrd_->interrupt();
+}
+
+void
+interrupter::impl::reset()
+{
+ unique_lock< mutex > lk( mtx_);
+ thrd_.reset();
+ BOOST_ASSERT( ! thrd_);
+ try
+ { this_thread::interruption_point(); }
+ catch ( thread_interrupted const&)
+ {}
+ BOOST_ASSERT( ! this_thread::interruption_requested() );
+ cond_.notify_all();
+}
+
+void
+interrupter::impl::interrupt()
+{
+ unique_lock< mutex > lk( mtx_);
+ interrupt_();
+}
+
+void
+interrupter::impl::interrupt_and_wait()
+{
+ unique_lock< mutex > lk( mtx_);
+ interrupt_();
+ cond_.wait( lk);
+}
+
+void
+interrupter::impl::interrupt_and_wait( system_time const& abs_time)
+{
+ unique_lock< mutex > lk( mtx_);
+ interrupt_();
+ cond_.timed_wait( lk, abs_time);
+}
+
+bool
+interrupter::impl::interruption_requested()
+{
+ unique_lock< mutex > lk( mtx_);
+ return interruption_requested_;
+}
+
+interrupter::interrupter()
+: impl_( new impl() )
+{}
+
+void
+interrupter::set( shared_ptr< thread > const& thrd)
+{ impl_->set( thrd); }
+
+void
+interrupter::reset()
+{ impl_->reset(); }
+
+void
+interrupter::interrupt()
+{ impl_->interrupt(); }
+
+void
+interrupter::interrupt_and_wait()
+{ impl_->interrupt_and_wait(); }
+
+void
+interrupter::interrupt_and_wait( system_time const& abs_time)
+{ impl_->interrupt_and_wait( abs_time); }
+
+bool
+interrupter::interruption_requested()
+{ return impl_->interruption_requested(); }
+}
+} }
+

Added: sandbox/async/libs/tp/src/poolsize.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/src/poolsize.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,12 @@
+#include "boost/tp/poolsize.hpp"
+
+namespace boost { namespace tp
+{
+poolsize::poolsize( std::size_t value)
+: value_( value)
+{ if ( value <= 0) throw invalid_poolsize("core poolsize must be greater than zero"); }
+
+poolsize::operator std::size_t () const
+{ return value_; }
+} }
+

Added: sandbox/async/libs/tp/src/scanns.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/src/scanns.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,12 @@
+#include "boost/tp/scanns.hpp"
+
+namespace boost { namespace tp
+{
+scanns::scanns( std::size_t value)
+: value_( value)
+{ if ( value < 0) throw invalid_scanns("scanns must be greater than or equal to zero"); }
+
+scanns::operator std::size_t () const
+{ return value_; }
+} }
+

Added: sandbox/async/libs/tp/src/watermark.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/src/watermark.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,24 @@
+#include "boost/tp/watermark.hpp"
+
+namespace boost { namespace tp
+{
+high_watermark::high_watermark( std::size_t value)
+: value_( value)
+{
+ if ( value <= 0)
+ throw invalid_watermark("high watermark must be greater than zero");
+}
+
+high_watermark::operator std::size_t () const
+{ return value_; }
+
+low_watermark::low_watermark( std::size_t value)
+: value_( value)
+{
+ if ( value < 0)
+ throw invalid_watermark("low watermark must be greater than or equal to zero");
+}
+
+low_watermark::operator std::size_t () const
+{ return value_; }
+} }

Added: sandbox/async/libs/tp/src/worker.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/src/worker.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,189 @@
+#include "boost/tp/detail/worker.hpp"
+
+namespace boost {
+namespace tp {
+namespace detail
+{
+thread_specific_ptr< worker > worker::tss_;
+
+worker::impl::impl( function< void() > const& fn)
+:
+thrd_( new thread( fn) ),
+wsq_(),
+shtdwn_sem_( 0),
+shtdwn_now_sem_( 0),
+shtdwn_( false),
+scns_( 0)
+{ BOOST_ASSERT( ! fn.empty() ); }
+
+const shared_ptr< thread >
+worker::impl::thrd() const
+{ return thrd_; }
+
+const thread::id
+worker::impl::get_id() const
+{ return thrd_->get_id(); }
+
+void
+worker::impl::join() const
+{ thrd_->join(); }
+
+void
+worker::impl::interrupt() const
+{ thrd_->interrupt(); }
+
+void
+worker::impl::put(
+ callable const& ca,
+ interrupter const& intr)
+{
+ BOOST_ASSERT( ! ca.empty() );
+ wsq_.put( std::make_pair( ca, intr) );
+}
+
+bool
+worker::impl::try_take(
+ callable & ca,
+ interrupter & intr)
+{
+ item itm;
+ bool result( wsq_.try_take( itm) );
+ if ( result)
+ {
+ ca = itm.first;
+ intr = itm.second;
+ }
+ return result;
+}
+
+bool
+worker::impl::try_steal(
+ callable & ca,
+ interrupter & intr)
+{
+ item itm;
+ bool result( wsq_.try_steal( itm) );
+ if ( result)
+ {
+ ca = itm.first;
+ intr = itm.second;
+ }
+ return result;
+}
+
+bool
+worker::impl::empty()
+{ return wsq_.empty(); }
+
+void
+worker::impl::signal_shutdown()
+{ shtdwn_sem_.post(); }
+
+void
+worker::impl::signal_shutdown_now()
+{ shtdwn_now_sem_.post(); }
+
+bool
+worker::impl::shutdown()
+{
+ if ( ! shtdwn_)
+ shtdwn_ = shtdwn_sem_.try_wait();
+ return shtdwn_;
+}
+
+bool
+worker::impl::shutdown_now()
+{ return shtdwn_now_sem_.try_wait(); }
+
+std::size_t
+worker::impl::scanns() const
+{ return scns_; }
+
+void
+worker::impl::increment_scanns()
+{ ++scns_; }
+
+void
+worker::impl::reset_scanns()
+{ scns_ = 0; }
+
+const shared_ptr< thread >
+worker::thrd() const
+{ return impl_->thrd(); }
+
+const thread::id
+worker::get_id() const
+{ return impl_->get_id(); }
+
+void
+worker::join() const
+{ impl_->join(); }
+
+void
+worker::interrupt() const
+{ impl_->interrupt(); }
+
+void
+worker::put(
+ callable const& ca,
+ interrupter const& intr)
+{ impl_->put( ca, intr); }
+
+bool
+worker::try_take(
+ callable & ca,
+ interrupter & intr)
+{ return impl_->try_take( ca, intr); }
+
+bool
+worker::try_steal(
+ callable & ca,
+ interrupter & intr)
+{ return impl_->try_steal( ca, intr); }
+
+bool
+worker::empty() const
+{ return impl_->empty(); }
+
+void
+worker::signal_shutdown()
+{ impl_->signal_shutdown(); }
+
+void
+worker::signal_shutdown_now()
+{ impl_->signal_shutdown_now(); }
+
+bool
+worker::shutdown()
+{ return impl_->shutdown(); }
+
+bool
+worker::shutdown_now()
+{ return impl_->shutdown_now(); }
+
+std::size_t
+worker::scanns() const
+{ return impl_->scanns(); }
+
+void
+worker::increment_scanns()
+{ impl_->increment_scanns(); }
+
+void
+worker::reset_scanns()
+{ impl_->reset_scanns(); }
+
+void
+worker::reschedule_until( function< bool() > const& pred)
+{ return impl_->reschedule_until( pred); }
+
+worker *
+worker::tss_get()
+{ return worker::tss_.get(); }
+
+void
+worker::tss_reset( worker * w)
+{ worker::tss_.reset( w); }
+
+} } }
+

Added: sandbox/async/libs/tp/test/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/Jamfile.v2 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,41 @@
+# Boost.ThreadPool Library Test Jamfile
+
+# Copyright (C) 2008 Oliver Kowalke
+
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# bring in rules for testing
+import testing ;
+
+project
+ : requirements
+ <library>/boost/test//boost_unit_test_framework
+ <library>/boost/thread//boost_thread
+ <library>/boost/system//boost_system
+ #<library>/boost/exception//boost_exception
+ <library>../../tp/build//boost_threadpool
+ <link>static
+ <threading>multi
+ <include>../../..
+ <include>$(BOOST_ROOT)
+ ;
+
+rule tp-test ( source )
+{
+ return
+ [ run $(source).cpp ]
+ ;
+}
+
+test-suite thread_pool :
+ [ tp-test test_bounded_queue_fifo ]
+ [ tp-test test_bounded_queue_lifo ]
+ [ tp-test test_bounded_queue_priority ]
+ [ tp-test test_bounded_queue_smart ]
+ [ tp-test test_unbounded_queue_fifo ]
+ [ tp-test test_unbounded_queue_lifo ]
+ [ tp-test test_unbounded_queue_priority ]
+ [ tp-test test_unbounded_queue_smart ]
+ ;

Added: sandbox/async/libs/tp/test/test_bounded_queue_fifo.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_bounded_queue_fifo.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,304 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/fifo.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/task.hpp>
+#include <boost/tp/watermark.hpp>
+
+#include "test_functions.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+class fixed_bounded_channel_fifo
+{
+public:
+ // check size, active, idle
+ void test_case_1()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool(
+ tp::poolsize( 3),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ }
+
+ // check submit
+ void test_case_2()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check shutdown
+ void test_case_3()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check runtime_error throw inside task
+ void test_case_4()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn) ) );
+ pool.shutdown();
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( std::runtime_error const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown with task_rejected exception
+ void test_case_5()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ bool thrown( false);
+ try
+ {
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ }
+ catch ( tp::task_rejected const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown_now with thread_interrupted exception
+ void test_case_6()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 1),
+ tp::low_watermark( 1) );
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, pt::time_duration const&) ) delay_fn,
+ fn,
+ pt::millisec( 500) ) ) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ pool.shutdown_now();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check pending
+ void test_case_7()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) ) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ tp::task< int > t2( pool.submit( fn) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 1) );
+ tp::task< int > t3( pool.submit( fn) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 2) );
+ b.wait();
+ BOOST_CHECK_EQUAL( t1.result().get(), 55);
+ BOOST_CHECK_EQUAL( t2.result().get(), 55);
+ BOOST_CHECK_EQUAL( t3.result().get(), 55);
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ }
+
+ // check fifo scheduling
+ void test_case_8()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) );
+ std::vector< int > buffer;
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0) );
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 55);
+ BOOST_CHECK_EQUAL( buffer[1], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 2) );
+ }
+
+ // check cancelation
+ void test_case_9()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::fifo >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) );
+ std::vector< int > buffer;
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10) ) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0) );
+ t.interrupt();
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 1) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+};
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+ boost::unit_test::test_suite * test( BOOST_TEST_SUITE("Boost.ThreadPool: fixed bounded_channel< fifo > pool test suite") );
+
+ boost::shared_ptr< fixed_bounded_channel_fifo > instance( new fixed_bounded_channel_fifo() );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_1, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_2, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_3, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_4, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_5, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_6, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_7, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_8, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_fifo::test_case_9, instance) );
+
+ return test;
+}
+

Added: sandbox/async/libs/tp/test/test_bounded_queue_lifo.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_bounded_queue_lifo.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,304 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/lifo.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/task.hpp>
+#include <boost/tp/watermark.hpp>
+
+#include "test_functions.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+class fixed_bounded_channel_lifo
+{
+public:
+ // check size, active, idle
+ void test_case_1()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool(
+ tp::poolsize( 3),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ }
+
+ // check submit
+ void test_case_2()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check shutdown
+ void test_case_3()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check runtime_error throw inside task
+ void test_case_4()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn) ) );
+ pool.shutdown();
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( std::runtime_error const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown with task_rejected exception
+ void test_case_5()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ bool thrown( false);
+ try
+ {
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ }
+ catch ( tp::task_rejected const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown_now with thread_interrupted exception
+ void test_case_6()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 1),
+ tp::low_watermark( 1) );
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, pt::time_duration const&) ) delay_fn,
+ fn,
+ pt::millisec( 500) ) ) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ pool.shutdown_now();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check pending
+ void test_case_7()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) ) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ tp::task< int > t2( pool.submit( fn) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 1) );
+ tp::task< int > t3( pool.submit( fn) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 2) );
+ b.wait();
+ BOOST_CHECK_EQUAL( t1.result().get(), 55);
+ BOOST_CHECK_EQUAL( t2.result().get(), 55);
+ BOOST_CHECK_EQUAL( t3.result().get(), 55);
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ }
+
+ // check lifo scheduling
+ void test_case_8()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) );
+ std::vector< int > buffer;
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0) );
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer[1], 55);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 2) );
+ }
+
+ // check cancelation
+ void test_case_9()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::lifo >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) );
+ std::vector< int > buffer;
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10) ) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0) );
+ t.interrupt();
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 1) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+};
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+ boost::unit_test::test_suite * test( BOOST_TEST_SUITE("Boost.ThreadPool: fixed bounded_channel< lifo > pool test suite") );
+
+ boost::shared_ptr< fixed_bounded_channel_lifo > instance( new fixed_bounded_channel_lifo() );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_1, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_2, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_3, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_4, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_5, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_6, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_7, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_8, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_lifo::test_case_9, instance) );
+
+ return test;
+}
+

Added: sandbox/async/libs/tp/test/test_bounded_queue_priority.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_bounded_queue_priority.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,318 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/priority.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/task.hpp>
+#include <boost/tp/watermark.hpp>
+
+#include "test_functions.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+class fixed_bounded_channel_priority
+{
+public:
+ // check size, active, idle
+ void test_case_1()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool(
+ tp::poolsize( 3),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ }
+
+ // check submit
+ void test_case_2()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0) );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check shutdown
+ void test_case_3()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check runtime_error throw inside task
+ void test_case_4()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn),
+ 0) );
+ pool.shutdown();
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( std::runtime_error const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown with task_rejected exception
+ void test_case_5()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ bool thrown( false);
+ try
+ {
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0);
+ }
+ catch ( tp::task_rejected const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown_now with thread_interrupted exception
+ void test_case_6()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 1),
+ tp::low_watermark( 1) );
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, pt::time_duration const&) ) delay_fn,
+ fn,
+ pt::millisec( 500) ),
+ 0) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 0) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 1) );
+ pool.shutdown_now();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check pending
+ void test_case_7()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ tp::task< int > t2( pool.submit( fn, 0) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 1) );
+ tp::task< int > t3( pool.submit( fn, 0) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 2) );
+ b.wait();
+ BOOST_CHECK_EQUAL( t1.result().get(), 55);
+ BOOST_CHECK_EQUAL( t2.result().get(), 55);
+ BOOST_CHECK_EQUAL( t3.result().get(), 55);
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ }
+
+ // check priority scheduling
+ void test_case_8()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0);
+ std::vector< int > buffer;
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10),
+ 1);
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0),
+ 0);
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer[1], 55);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 2) );
+ }
+
+ // check cancelation
+ void test_case_9()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::priority< int > >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0);
+ std::vector< int > buffer;
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10),
+ 0) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0),
+ 0);
+ t.interrupt();
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 1) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+};
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+ boost::unit_test::test_suite * test( BOOST_TEST_SUITE("Boost.ThreadPool: fixed bounded_channel< priority< int > > pool test suite") );
+
+ boost::shared_ptr< fixed_bounded_channel_priority > instance( new fixed_bounded_channel_priority() );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_1, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_2, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_3, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_4, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_5, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_6, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_7, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_8, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_priority::test_case_9, instance) );
+
+ return test;
+}
+

Added: sandbox/async/libs/tp/test/test_bounded_queue_smart.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_bounded_queue_smart.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,324 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/smart.hpp>
+#include <boost/tp/task.hpp>
+#include <boost/tp/watermark.hpp>
+
+#include "test_functions.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+class fixed_bounded_channel_smart
+{
+public:
+ // check size, active, idle
+ void test_case_1()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool(
+ tp::poolsize( 3),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ }
+
+ // check submit
+ void test_case_2()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0) );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check shutdown
+ void test_case_3()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check runtime_error throw inside task
+ void test_case_4()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn),
+ 0) );
+ pool.shutdown();
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( std::runtime_error const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown with task_rejected exception
+ void test_case_5()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ bool thrown( false);
+ try
+ {
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0);
+ }
+ catch ( tp::task_rejected const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown_now with thread_interrupted exception
+ void test_case_6()
+ {
+ tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 1),
+ tp::low_watermark( 1) );
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, pt::time_duration const&) ) delay_fn,
+ fn,
+ pt::millisec( 500) ),
+ 0) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 0) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 1) );
+ pool.shutdown_now();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check pending
+ void test_case_7()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ tp::task< int > t2( pool.submit( fn, 1) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 1) );
+ tp::task< int > t3( pool.submit( fn, 2) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 2) );
+ b.wait();
+ BOOST_CHECK_EQUAL( t1.result().get(), 55);
+ BOOST_CHECK_EQUAL( t2.result().get(), 55);
+ BOOST_CHECK_EQUAL( t3.result().get(), 55);
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ }
+
+ // check smart scheduling
+ void test_case_8()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0);
+ std::vector< int > buffer;
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10),
+ 2);
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0),
+ 1);
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 1),
+ 2);
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer[1], 1);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 2) );
+ }
+
+ // check cancelation
+ void test_case_9()
+ {
+ typedef tp::pool<
+ tp::bounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool_type;
+ pool_type pool(
+ tp::poolsize( 1),
+ tp::high_watermark( 10),
+ tp::low_watermark( 10) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0);
+ std::vector< int > buffer;
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10),
+ 2) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0),
+ 1);
+ t.interrupt();
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 1) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+};
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+ boost::unit_test::test_suite * test( BOOST_TEST_SUITE("Boost.ThreadPool: fixed bounded_channel< smart< int > > pool test suite") );
+
+ boost::shared_ptr< fixed_bounded_channel_smart > instance( new fixed_bounded_channel_smart() );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_1, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_2, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_3, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_4, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_5, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_6, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_7, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_8, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_bounded_channel_smart::test_case_9, instance) );
+
+ return test;
+}
+

Added: sandbox/async/libs/tp/test/test_functions.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_functions.hpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,94 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TP_TEST_FUNCTIONS_H
+#define BOOST_TP_TEST_FUNCTIONS_H
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/fifo.hpp>
+#include <boost/tp/lifo.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/priority.hpp>
+#include <boost/tp/smart.hpp>
+#include <boost/tp/task.hpp>
+#include <boost/tp/unbounded_channel.hpp>
+#include <boost/tp/watermark.hpp>
+
+#include <boost/tp/detail/interrupter.hpp>
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+inline
+int add_fn(
+ int a,
+ int b)
+{
+ boost::this_thread::interruption_point();
+ return a + b;
+}
+
+template< typename Fn >
+typename boost::result_of< Fn() >::type barrier_fn(
+ Fn const& fn,
+ boost::barrier & b)
+{
+ b.wait();
+ return fn();
+}
+
+template< typename Fn >
+typename boost::result_of< Fn() >::type delay_fn(
+ Fn const& fn,
+ pt::time_duration const& td)
+{
+ boost::this_thread::sleep( td);
+ return fn();
+}
+
+inline
+int fibonacci_fn( int n)
+{
+ if ( n < 2) return n;
+ int k1( 1), k2( 0);
+ for ( int i( 2); i <= n; ++i)
+ {
+ boost::this_thread::interruption_point();
+ int tmp( k1);
+ k1 = k1 + k2;
+ k2 = tmp;
+ }
+ boost::this_thread::interruption_point();
+ return k1;
+}
+
+inline
+void buffer_fibonacci_fn(
+ std::vector< int > & buffer,
+ int n)
+{ buffer.push_back( fibonacci_fn( n) ); }
+
+inline
+void throwing_fn()
+{ throw std::runtime_error("exception thrown"); }
+
+#endif // BOOST_TP_TEST_FUNCTIONS_H

Added: sandbox/async/libs/tp/test/test_unbounded_queue_fifo.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_unbounded_queue_fifo.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,275 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/fifo.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/task.hpp>
+
+#include "test_functions.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+class fixed_unbounded_channel_fifo
+{
+public:
+ // check size, active, idle
+ void test_case_1()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 3) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ }
+
+ // check submit
+ void test_case_2()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check shutdown
+ void test_case_3()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check runtime_error throw inside task
+ void test_case_4()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn) ) );
+ pool.shutdown();
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( std::runtime_error const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown with task_rejected exception
+ void test_case_5()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ bool thrown( false);
+ try
+ {
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ }
+ catch ( tp::task_rejected const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown_now with thread_interrupted exception
+ void test_case_6()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool( tp::poolsize( 1) );
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, pt::time_duration const&) ) delay_fn,
+ fn,
+ pt::millisec( 500) ) ) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ pool.shutdown_now();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check pending
+ void test_case_7()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) ) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ tp::task< int > t2( pool.submit( fn) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 1) );
+ tp::task< int > t3( pool.submit( fn) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 2) );
+ b.wait();
+ BOOST_CHECK_EQUAL( t1.result().get(), 55);
+ BOOST_CHECK_EQUAL( t2.result().get(), 55);
+ BOOST_CHECK_EQUAL( t3.result().get(), 55);
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ }
+
+ // check fifo scheduling
+ void test_case_8()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) );
+ std::vector< int > buffer;
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0) );
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 55);
+ BOOST_CHECK_EQUAL( buffer[1], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 2) );
+ }
+
+ // check interruptation
+ void test_case_9()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::fifo >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) );
+ std::vector< int > buffer;
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10) ) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0) );
+ t.interrupt();
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 1) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+};
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+ boost::unit_test::test_suite * test( BOOST_TEST_SUITE("Boost.ThreadPool: fixed unbounded_channel< fifo > pool test suite") );
+
+ boost::shared_ptr< fixed_unbounded_channel_fifo > instance( new fixed_unbounded_channel_fifo() );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_1, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_2, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_3, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_4, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_5, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_6, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_7, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_8, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_fifo::test_case_9, instance) );
+
+ return test;
+}

Added: sandbox/async/libs/tp/test/test_unbounded_queue_lifo.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_unbounded_queue_lifo.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,275 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/lifo.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/task.hpp>
+
+#include "test_functions.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+class fixed_unbounded_channel_lifo
+{
+public:
+ // check size, active, idle
+ void test_case_1()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool( tp::poolsize( 3) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ }
+
+ // check submit
+ void test_case_2()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check shutdown
+ void test_case_3()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) ) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check runtime_error throw inside task
+ void test_case_4()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool( tp::poolsize( 1) );
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn) ) );
+ pool.shutdown();
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( std::runtime_error const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown with task_rejected exception
+ void test_case_5()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool( tp::poolsize( 1) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ bool thrown( false);
+ try
+ {
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ }
+ catch ( tp::task_rejected const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown_now with thread_interrupted exception
+ void test_case_6()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool( tp::poolsize( 1) );
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, pt::time_duration const&) ) delay_fn,
+ fn,
+ pt::millisec( 500) ) ) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ pool.shutdown_now();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check pending
+ void test_case_7()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) ) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ tp::task< int > t2( pool.submit( fn) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 1) );
+ tp::task< int > t3( pool.submit( fn) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 2) );
+ b.wait();
+ BOOST_CHECK_EQUAL( t1.result().get(), 55);
+ BOOST_CHECK_EQUAL( t2.result().get(), 55);
+ BOOST_CHECK_EQUAL( t3.result().get(), 55);
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ }
+
+ // check lifo scheduling
+ void test_case_8()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) );
+ std::vector< int > buffer;
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0) );
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer[1], 55);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 2) );
+ }
+
+ // check interruptation
+ void test_case_9()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::lifo >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ) );
+ std::vector< int > buffer;
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10) ) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0) );
+ t.interrupt();
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 1) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+};
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+ boost::unit_test::test_suite * test( BOOST_TEST_SUITE("Boost.ThreadPool: fixed unbounded_channel< lifo > pool test suite") );
+
+ boost::shared_ptr< fixed_unbounded_channel_lifo > instance( new fixed_unbounded_channel_lifo() );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_1, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_2, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_3, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_4, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_5, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_6, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_7, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_8, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_lifo::test_case_9, instance) );
+
+ return test;
+}

Added: sandbox/async/libs/tp/test/test_unbounded_queue_priority.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_unbounded_queue_priority.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,290 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/priority.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/task.hpp>
+
+#include "test_functions.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+class fixed_unbounded_channel_priority
+{
+public:
+ // check size, active, idle
+ void test_case_1()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool( tp::poolsize( 3) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ }
+
+ // check submit
+ void test_case_2()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0) );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check shutdown
+ void test_case_3()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check runtime_error throw inside task
+ void test_case_4()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool( tp::poolsize( 1) );
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn),
+ 0) );
+ pool.shutdown();
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( std::runtime_error const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown with task_rejected exception
+ void test_case_5()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool( tp::poolsize( 1) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ bool thrown( false);
+ try
+ {
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0);
+ }
+ catch ( tp::task_rejected const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown_now with thread_interrupted exception
+ void test_case_6()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool( tp::poolsize( 1) );
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, pt::time_duration const&) ) delay_fn,
+ fn,
+ pt::millisec( 500) ),
+ 0) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 0) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 1) );
+ pool.shutdown_now();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check pending
+ void test_case_7()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ tp::task< int > t2( pool.submit( fn, 0) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 1) );
+ tp::task< int > t3( pool.submit( fn, 0) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 2) );
+ b.wait();
+ BOOST_CHECK_EQUAL( t1.result().get(), 55);
+ BOOST_CHECK_EQUAL( t2.result().get(), 55);
+ BOOST_CHECK_EQUAL( t3.result().get(), 55);
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ }
+
+ // check priority scheduling
+ void test_case_8()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0);
+ std::vector< int > buffer;
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10),
+ 1);
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0),
+ 0);
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer[1], 55);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 2) );
+ }
+
+ // check interruptation
+ void test_case_9()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::priority< int > >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0);
+ std::vector< int > buffer;
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10),
+ 0) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0),
+ 0);
+ t.interrupt();
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 1) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+};
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+ boost::unit_test::test_suite * test( BOOST_TEST_SUITE("Boost.ThreadPool: fixed unbounded_channel< priority< int > > pool test suite") );
+
+ boost::shared_ptr< fixed_unbounded_channel_priority > instance( new fixed_unbounded_channel_priority() );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_1, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_2, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_3, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_4, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_5, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_6, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_7, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_8, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_priority::test_case_9, instance) );
+
+ return test;
+}
+

Added: sandbox/async/libs/tp/test/test_unbounded_queue_smart.cpp
==============================================================================
--- (empty file)
+++ sandbox/async/libs/tp/test/test_unbounded_queue_smart.cpp 2009-10-13 03:35:29 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,296 @@
+// Copyright (c) 2008 Oliver Kowalke. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/future.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/tp/bounded_channel.hpp>
+#include <boost/tp/exceptions.hpp>
+#include <boost/tp/pool.hpp>
+#include <boost/tp/poolsize.hpp>
+#include <boost/tp/smart.hpp>
+#include <boost/tp/task.hpp>
+
+#include "test_functions.hpp"
+
+namespace pt = boost::posix_time;
+namespace tp = boost::tp;
+
+class fixed_unbounded_channel_smart
+{
+public:
+ // check size, active, idle
+ void test_case_1()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool( tp::poolsize( 3) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 3) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ }
+
+ // check submit
+ void test_case_2()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0) );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check shutdown
+ void test_case_3()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool( tp::poolsize( 1) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( t.result().get(), 55);
+ }
+
+ // check runtime_error throw inside task
+ void test_case_4()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool( tp::poolsize( 1) );
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ throwing_fn),
+ 0) );
+ pool.shutdown();
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( std::runtime_error const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown with task_rejected exception
+ void test_case_5()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool( tp::poolsize( 1) );
+ pool.shutdown();
+ BOOST_CHECK( pool.terminated() );
+ bool thrown( false);
+ try
+ {
+ pool.submit(
+ boost::bind(
+ fibonacci_fn,
+ 10),
+ 0);
+ }
+ catch ( tp::task_rejected const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check shutdown_now with boost::thread_interrupted exception
+ void test_case_6()
+ {
+ tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool( tp::poolsize( 1) );
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, pt::time_duration const&) ) delay_fn,
+ fn,
+ pt::millisec( 500) ),
+ 0) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 0) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 1) );
+ pool.shutdown_now();
+ BOOST_CHECK( pool.terminated() );
+ BOOST_CHECK_EQUAL( pool.size(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.idle(), std::size_t( 1) );
+ BOOST_CHECK_EQUAL( pool.active(), std::size_t( 0) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+
+ // check pending
+ void test_case_7()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ tp::task< int > t1(
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0) );
+ boost::this_thread::sleep( pt::millisec( 250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ tp::task< int > t2( pool.submit( fn, 1) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 1) );
+ tp::task< int > t3( pool.submit( fn, 2) );
+ boost::this_thread::sleep( pt::millisec(250) );
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 2) );
+ b.wait();
+ BOOST_CHECK_EQUAL( t1.result().get(), 55);
+ BOOST_CHECK_EQUAL( t2.result().get(), 55);
+ BOOST_CHECK_EQUAL( t3.result().get(), 55);
+ BOOST_CHECK_EQUAL( pool.pending(), std::size_t( 0) );
+ }
+
+ // check smart scheduling
+ void test_case_8()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0);
+ std::vector< int > buffer;
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10),
+ 2);
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0),
+ 1);
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 1),
+ 2);
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer[1], 1);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 2) );
+ }
+
+ // check interruptation
+ void test_case_9()
+ {
+ typedef tp::pool<
+ tp::unbounded_channel< tp::smart< int, std::less< int >, tp::replace_oldest, tp::take_oldest > >
+ > pool_type;
+ pool_type pool( tp::poolsize( 1) );
+ boost::barrier b( 2);
+ boost::function< int() > fn(
+ boost::bind(
+ fibonacci_fn,
+ 10) );
+ pool.submit(
+ boost::bind(
+ ( int ( *)( boost::function< int() > const&, boost::barrier &) ) barrier_fn,
+ fn,
+ boost::ref( b) ),
+ 0);
+ std::vector< int > buffer;
+ tp::task< void > t(
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 10),
+ 2) );
+ pool.submit(
+ boost::bind(
+ buffer_fibonacci_fn,
+ boost::ref( buffer),
+ 0),
+ 1);
+ t.interrupt();
+ b.wait();
+ pool.shutdown();
+ BOOST_CHECK_EQUAL( buffer[0], 0);
+ BOOST_CHECK_EQUAL( buffer.size(), std::size_t( 1) );
+ bool thrown( false);
+ try
+ { t.result().get(); }
+ catch ( boost::thread_interrupted const&)
+ { thrown = true; }
+ BOOST_CHECK( thrown);
+ }
+};
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+ boost::unit_test::test_suite * test( BOOST_TEST_SUITE("Boost.ThreadPool: fixed unbounded_channel< smart< int > > pool test suite") );
+
+ boost::shared_ptr< fixed_unbounded_channel_smart > instance( new fixed_unbounded_channel_smart() );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_1, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_2, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_3, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_4, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_5, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_6, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_7, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_8, instance) );
+ test->add( BOOST_CLASS_TEST_CASE( & fixed_unbounded_channel_smart::test_case_9, instance) );
+
+ return test;
+}
+

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk