merge from develop.

build/Jamfile.v2

@@ -60,8 +60,7 @@ project boost/thread
         <toolset>gcc:<cxxflags>-Wno-long-long
         #<toolset>gcc:<cxxflags>-ansi
         #<toolset>gcc:<cxxflags>-fpermissive
-        <toolset>gcc-4:<cxxflags>-Wno-variadic-macros
-        <toolset>gcc-5:<cxxflags>-Wno-variadic-macros
+        <toolset>gcc:<cxxflags>-Wno-variadic-macros
         #<toolset>gcc:<cxxflags>-Wunused-local-typedefs
         <toolset>gcc:<cxxflags>-Wunused-function
         <toolset>gcc:<cxxflags>-Wno-unused-parameter
@@ -71,9 +70,7 @@ project boost/thread
         #<toolset>darwin:<cxxflags>-ansi
         <toolset>darwin:<cxxflags>-fpermissive
         <toolset>darwin:<cxxflags>-Wno-long-long
-        #<toolset>darwin:<cxxflags>-Wno-variadic-macros
-        <toolset>darwin-4:<cxxflags>-Wno-variadic-macros
-        <toolset>darwin-5:<cxxflags>-Wno-variadic-macros
+        <toolset>darwin:<cxxflags>-Wno-variadic-macros
         #<toolset>darwin:<cxxflags>-Wunused-local-typedefs
         <toolset>darwin:<cxxflags>-Wunused-function
         <toolset>darwin:<cxxflags>-Wno-unused-parameter

doc/acknowledgements.qbk

@@ -1,6 +1,5 @@
 [/
   (C) Copyright 2007-8 Anthony Williams.
-  (C) Copyright 2012-2015 Vicente J. Botet Escriba.
   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).

doc/async_executors.qbk

@@ -174,7 +174,7 @@ This has several advantages:
 * The scheduled operations are available for all the executors via wrappers.
 * The template functions could accept any chrono `time_point` and `duration` respectively as we are not working with virtual functions.
 
-In order to manage with all the clocks, this library propose generic solution. `scheduler<Clock>` know how to manage with the `submit_at`/`submit_after` `Clock::time_point`/`Clock::duration` tasks. Note that the durations on different clocks differ.
+In order to manage with all the clocks, this library propose a generic solution. `scheduler<Clock>` know how to manage with the `submit_at`/`submit_after` `Clock::time_point`/`Clock::duration` tasks. Note that the durations on different clocks differ.
 
 [heading Not Handled Exceptions]
 As in N3785 and based on the same design decision than `std`/`boost::thread` if a user closure throws an exception, the executor must call the `std::terminate` function.
@@ -411,7 +411,7 @@ If invoked closure throws an exception the executor will call std::terminate, as
 
 [variablelist
 
-[[Effects:] [close the executor `e` for submissions.]]
+[[Effects:] [close the scheduler/executor `e` for submissions.]]
 
 [[Remark:] [The worker threads will work until there is no more closures to run.]]
 
@@ -431,7 +431,7 @@ If invoked closure throws an exception the executor will call std::terminate, as
 
 [[Return type:] [`bool`.]]
 
-[[Return:] [whether the executor is closed for submissions.]]
+[[Return:] [whether the scheduler/executor is closed for submissions.]]
 
 [[Throws:] [Whatever exception that can be throw while ensuring the thread safety.]]
 
@@ -506,9 +506,6 @@ Executor abstract base class.
     public:
       typedef  boost::work work;
   
-      executor(executor const&) = delete;
-      executor& operator=(executor const&) = delete;
-
       executor(); 
       virtual ~executor() {};
   
@@ -573,9 +570,6 @@ Polymorphic adaptor of a model of Executor to an executor.
     public:
       typedef  executor::work work;
   
-      executor_adaptor(executor_adaptor const&) = delete;
-      executor_adaptor& operator=(executor_adaptor const&) = delete;
-  
       template <typename ...Args>
       executor_adaptor(Args&& ... args);
 
@@ -641,20 +635,24 @@ Polymorphic adaptor of a model of Executor to an executor.
 [/////////////////////////////////]
 [section:generic_executor_ref Class `generic_executor_ref`]
 
-Executor abstract base class.
+Type erased executor class.
 
   #include <boost/thread/generic_executor_ref.hpp>
   namespace boost {
     class generic_executor_ref
     {
     public:
-      generic_executor_ref(generic_executor_ref const&);
-      generic_executor_ref& operator=(generic_executor_ref const&);
 
       template <class Executor>
       generic_executor_ref(Executor& ex); 
-      generic_executor_ref() {};
+      generic_executor_ref() = delete;
+      generic_executor_ref(generic_executor_ref const&) = default;
+      generic_executor_ref(generic_executor_ref &&) = default;
+      generic_executor_ref& operator=(generic_executor_ref const&) = default;
+      generic_executor_ref& operator=(generic_executor_ref &&) = default;
   
+      executor& underlying_executor() noexcept;
+
       void close() = 0;
       bool closed() = 0;
   
@@ -669,6 +667,44 @@ Executor abstract base class.
 
 [endsect]
 
+
+[/////////////////////////////////]
+[section:generic_executor Class `generic_executor`]
+
+Type erased executor class.
+
+  #include <boost/thread/generic_executor.hpp>
+  namespace boost {
+    class generic_executor
+    {
+    public:
+
+      template <class Executor>
+      generic_executor(Executor& ex); 
+      generic_executor() = delete;
+
+      generic_executor(generic_executor const&) = default;
+      generic_executor(generic_executor &&) = default;
+      generic_executor& operator=(generic_executor const&) = default;
+      generic_executor& operator=(generic_executor &&) = default;
+  
+      executor& underlying_executor() noexcept;
+
+      void close() = 0;
+      bool closed() = 0;
+  
+      template <typename Closure>
+      void submit(Closure&& closure);
+  
+      virtual bool try_executing_one() = 0;
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred);
+    };
+  }
+
+[endsect]
+
+
 [//////////////////////////////////////////////////////////]
 [section: scheduler Template Class `scheduler `]
 
@@ -683,10 +719,7 @@ Scheduler providing time related functions. Note that `scheduler` is not an Exec
     public:
       using work = boost::function<void()> ;
       using clock = Clock;
-
-      scheduler(scheduler const&) = delete;
-      scheduler& operator=(scheduler const&) = delete;
-  
+ 
       scheduler();
       ~scheduler();
  
@@ -733,7 +766,7 @@ Scheduler providing time related functions. Note that `scheduler` is not an Exec
 
 [[Effects:] [Destroys the scheduler.]]
 
-[[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
+[[Synchronization:] [The completion of all the closures happen before the completion of the destructor.]]
 
 ]
 
@@ -814,7 +847,7 @@ Scheduler providing time related functions. Note that `scheduler` is not an Exec
   }
 
 [/////////////////////////////////////]
-[section:constructor Constructor `at_executor(Scheduler&, clock::time_point const&)`]
+[section:constructor Constructor `at_executor(Scheduler&)`]
 
       at_executor(Scheduler& sch, clock::time_point const& tp);
 
@@ -1339,10 +1372,6 @@ A serial executor ensuring that there are no two work units that executes concur
     class serial_executor
     {
     public:
-      serial_executor(serial_executor const&) = delete;
-      serial_executor& operator=(serial_executor const&) = delete;
-  
-      template <class Executor>
       serial_executor(Executor& ex);
  
       Executor& underlying_executor() noexcept;
@@ -1393,7 +1422,7 @@ A serial executor ensuring that there are no two work units that executes concur
 [/////////////////////////////////////]
 [section:underlying_executor Function member `underlying_executor()`]
 
-      generic_executor_ref& underlying_executor() noexcept;
+      Executor& underlying_executor() noexcept;
 
 [variablelist
 
@@ -1418,13 +1447,10 @@ A serial executor ensuring that there are no two work units that executes concur
     class generic_serial_executor
     {
     public:
-      generic_serial_executor(generic_serial_executor const&) = delete;
-      generic_serial_executor& operator=(generic_serial_executor const&) = delete;
-  
       template <class Executor>
       generic_serial_executor(Executor& ex);
  
-      generic_executor_ref& underlying_executor() noexcept;
+      generic_executor& underlying_executor() noexcept;
 
       void close();
       bool closed();
@@ -1433,6 +1459,7 @@ A serial executor ensuring that there are no two work units that executes concur
       void submit(Closure&& closure);
   
       bool try_executing_one();
+
       template <typename Pred>
       bool reschedule_until(Pred const& pred);
 
@@ -1456,7 +1483,7 @@ A serial executor ensuring that there are no two work units that executes concur
 
 [endsect]
 [/////////////////////////////////////]
-[section:destructor Destructor `~serial_executor()`]
+[section:destructor Destructor `~generic_serial_executor()`]
 
       ~generic_serial_executor();
 
@@ -1468,6 +1495,80 @@ A serial executor ensuring that there are no two work units that executes concur
 
 ]
 
+[endsect]
+[/////////////////////////////////////]
+[section:underlying_executor Function member `underlying_executor()`]
+
+      generic_executor& underlying_executor() noexcept;
+
+[variablelist
+
+[[Return:] [The underlying executor instance. ]]
+
+]
+
+
+[endsect]
+
+[endsect]
+
+[//////////////////////////////////////////////////////////]
+[section:serial_executor_cont Template Class `serial_executor_cont`]
+
+A serial executor ensuring that there are no two work units that executes concurrently.
+
+  #include <boost/thread/serial_executor_cont.hpp>
+  namespace boost {
+    template <class Executor>
+    class serial_executor_cont
+    {
+    public:
+      serial_executor_cont(Executor& ex);
+ 
+      Executor& underlying_executor() noexcept;
+
+      void close();
+      bool closed();
+  
+      template <typename Closure>
+      void submit(Closure&& closure);
+  
+      bool try_executing_one();
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred);
+
+    };
+  }
+
+[/////////////////////////////////////]
+[section:constructor Constructor `serial_executor_cont(Executor&)`]
+
+      template <class Executor>
+      serial_executor_cont(Executor& ex);
+
+[variablelist
+
+[[Effects:] [Constructs a serial_executor_cont. ]]
+
+[[Throws:] [Nothing. ]]
+
+]
+
+
+[endsect]
+[/////////////////////////////////////]
+[section:destructor Destructor `~serial_executor_cont()`]
+
+      ~serial_executor_cont();
+
+[variablelist
+
+[[Effects:] [Destroys the serial_executor.]]
+
+[[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
+
+]
+
 [endsect]
 [/////////////////////////////////////]
 [section:underlying_executor Function member `underlying_executor()`]
@@ -1478,6 +1579,8 @@ A serial executor ensuring that there are no two work units that executes concur
 
 [[Return:] [The underlying executor instance. ]]
 
+[[Throws:] [Nothing.]]
+
 ]
 
 
@@ -1485,6 +1588,82 @@ A serial executor ensuring that there are no two work units that executes concur
 
 [endsect]
 
+[//////////////////////////////////////////////////////////]
+[section:generic_serial_cont_executor Class `generic_serial_cont_executor`]
+
+A serial executor ensuring that there are no two work units that executes concurrently.
+
+  #include <boost/thread/generic_serial_cont_executor.hpp>
+  namespace boost {
+    class generic_serial_cont_executor
+    {
+    public:
+      template <class Executor>
+      generic_serial_cont_executor(Executor& ex);
+ 
+      generic_executor& underlying_executor() noexcept;
+
+      void close();
+      bool closed();
+  
+      template <typename Closure>
+      void submit(Closure&& closure);
+  
+      bool try_executing_one();
+
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred);
+
+    };
+  }
+
+[/////////////////////////////////////]
+[section:constructor Constructor `generic_serial_cont_executor(Executor&)`]
+
+      template <class Executor>
+      generic_serial_cont_executor(Executor& ex);
+
+[variablelist
+
+[[Effects:] [Constructs a generic_serial_cont_executor. ]]
+
+[[Throws:] [Nothing. ]]
+
+]
+
+
+[endsect]
+[/////////////////////////////////////]
+[section:destructor Destructor `~generic_serial_cont_executor()`]
+
+      ~generic_serial_cont_executor();
+
+[variablelist
+
+[[Effects:] [Destroys the generic_serial_cont_executor.]]
+
+[[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
+
+]
+
+[endsect]
+[/////////////////////////////////////]
+[section:underlying_executor Function member `underlying_executor()`]
+
+      generic_executor& underlying_executor() noexcept;
+
+[variablelist
+
+[[Return:] [The underlying executor instance. ]]
+
+]
+
+
+[endsect]
+
+[endsect]
+
+
 
 [//////////////////////////////////////////////////////////]
 [section:inline_executor Class `inline_executor`]
@@ -1496,10 +1675,8 @@ A serial executor ensuring that there are no two work units that executes concur
     class inline_executor
     {
     public:
-      inline_executor(inline_executor const&) = delete;
-      inline_executor& operator=(inline_executor const&) = delete;
-  
       inline_executor();
+      ~inline_executor();
  
       void close();
       bool closed();
@@ -1560,9 +1737,6 @@ A thread pool with up to a fixed number of threads.
     class basic_thread_pool
     { 
     public:
- 
-      basic_thread_pool(basic_thread_pool const&) = delete;
-      basic_thread_pool& operator=(basic_thread_pool const&) = delete;
   
       basic_thread_pool(unsigned const thread_count = thread::hardware_concurrency());
       template <class AtThreadEntry>
@@ -1623,9 +1797,6 @@ A thread_executor with a threads for each task.
     { 
     public:
  
-      thread_executor(thread_executor const&) = delete;
-      thread_executor& operator=(thread_executor const&) = delete;
-  
       thread_executor();
       template <class AtThreadEntry>
       basic_thread_pool( unsigned const thread_count, AtThreadEntry at_thread_entry);
@@ -1680,9 +1851,6 @@ A user scheduled executor.
     class loop_executor
     { 
     public:
- 
-      loop_executor(loop_executor const&) = delete;
-      loop_executor& operator=(loop_executor const&) = delete;
   
       loop_executor();
       ~loop_executor();

doc/barrier.qbk

@@ -1,6 +1,6 @@
 [/
   (C) Copyright 2007-8 Anthony Williams.
-  (C) Copyright 2013-2015 Vicente J. Botet Escriba.
+  (C) Copyright 2013 Vicente J. Botet Escriba.
   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).

doc/changes.qbk

@@ -1,6 +1,6 @@
 [/
   (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-15 Vicente J. Botet Escriba.
+  (C) Copyright 2011-14 Vicente J. Botet Escriba.
   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).
@@ -8,66 +8,6 @@
 
 [section:changes History]
 
-[heading Version 4.6.0 - boost 1.60]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/4833 #4833] MinGW/test_tss_lib: Support of automatic tss cleanup for native threading API not available
-* [@http://svn.boost.org/trac/boost/ticket/8600 #8600] wait_for_any hangs, if called with multiple copies of shared_future referencing same task
-* [@http://svn.boost.org/trac/boost/ticket/9118 #9118] Seg fault on thread join when llvm and libc++ are used
-* [@http://svn.boost.org/trac/boost/ticket/10942 #10942] Boost.Thread fails to build on Cygwin.
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last regression test snapshot.
-
-[*New Experimental Features:]
-
-
-* [@http://svn.boost.org/trac/boost/ticket/11231 #11231] Allow to set continuation future's destructor behavior to non-blocking
-* [@http://svn.boost.org/trac/boost/ticket/11424 #11424] Provide shared_timed_mutex as an alternative name for shared_mutex and deprecate the use of shared_mutex as a timed mutex
-* [@http://svn.boost.org/trac/boost/ticket/11734 #11734] future::then(Cont) should be able to execute the contination on undetermined thread
-* [@http://svn.boost.org/trac/boost/ticket/11736 #11736] Allow to use launch::executor on future::then(launch::executor, cont)
-* [@http://svn.boost.org/trac/boost/ticket/11737 #11737] Add a launch::inherit policy that can be used on ::then() to use the policy of the parent future
-
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-* [@http://svn.boost.org/trac/boost/ticket/6377 #6377] Condition variable blocks when changing time
-* [@http://svn.boost.org/trac/boost/ticket/6787 #6787] boost::thread::sleep() hangs if system time is rolled back
-* [@http://svn.boost.org/trac/boost/ticket/7665 #7665] this_thread::sleep_for no longer uses steady_clock in thread
-* [@http://svn.boost.org/trac/boost/ticket/7720 #7720] exception lock_error while intensive locking/unlocking of mutex
-* [@http://svn.boost.org/trac/boost/ticket/9309 #9309] test_latch fails often on clang-darwin-tot11
-* [@http://svn.boost.org/trac/boost/ticket/10788 #10788] GetLogicalProcessor isn't available for Windows platform less or equals to 0x0502
-* [@http://svn.boost.org/trac/boost/ticket/11090 #11090] ex_future_unwrap- ThreadSanitizer: lock-order-inversion (potential deadlock)
-* [@http://svn.boost.org/trac/boost/ticket/11158 #11158] Pthread thread deadlock when faketime used
-* [@http://svn.boost.org/trac/boost/ticket/11174 #11174] boost::condition_variable::timed_wait with predicate unexpectedly wakes up while should wait infinite
-* [@http://svn.boost.org/trac/boost/ticket/11185 #11185] Incorrect URL redirection
-* [@http://svn.boost.org/trac/boost/ticket/11192 #11192] boost::future<>::then() with an executor doesn't compile when the callback returns a future
-* [@http://svn.boost.org/trac/boost/ticket/11250 #11250] future made from make_exceptional fails on assertion in destructor
-* [@http://svn.boost.org/trac/boost/ticket/11256 #11256] future<>::is_ready() == false in continuation function
-* [@http://svn.boost.org/trac/boost/ticket/11261 #11261] bad use of scoped threads in basic_thread_pool
-* [@http://svn.boost.org/trac/boost/ticket/11262 #11262] bad use of direct pointer in shared_state_nullary_task
-* [@http://svn.boost.org/trac/boost/ticket/11263 #11263] lock already locked lock
-* [@http://svn.boost.org/trac/boost/ticket/11266 #11266] boost::packaged_task has invalid variadic signature
-* [@http://svn.boost.org/trac/boost/ticket/11302 #11302] boost thread doesn't build with BOOST_THREAD_PATCH.
-* [@http://svn.boost.org/trac/boost/ticket/11322 #11322] sleep_for() nanoseconds overload will always return too early on windows
-* [@http://svn.boost.org/trac/boost/ticket/11329 #11329] using declarative for GetProcessHeap, .... fails
-* [@http://svn.boost.org/trac/boost/ticket/11368 #11368] boost thread's usage of CreateWaitableTimer wakes PC from sleep (doh)
-* [@http://svn.boost.org/trac/boost/ticket/11377 #11377] Boost condition variable always waits for system clock deadline
-* [@http://svn.boost.org/trac/boost/ticket/11435 #11435] gcc compiler warning in future.hpp
-* [@http://svn.boost.org/trac/boost/ticket/11555 #11555] devector.hpp assumes allocator_traits_type is always present
-* [@http://svn.boost.org/trac/boost/ticket/11562 #11562] (condition_variable_any::wait_until + recursive_mutex + steady_clock) timer expires after computer time is set forward on Ubuntu 64-bit
-* [@http://svn.boost.org/trac/boost/ticket/11672 #11672] Thread: Should use unique_ptr, not auto_ptr
-* [@http://svn.boost.org/trac/boost/ticket/11688 #11688] thread::try_join_until: Avoid busy wait if system clock changes
-* [@http://svn.boost.org/trac/boost/ticket/11672 #11716] ::then(f) should inherit the parent Executor
-* [@http://svn.boost.org/trac/boost/ticket/11795 #11795] Incorrect version specification for documentation of thread destructor
-* [@http://svn.boost.org/trac/boost/ticket/11796 #11796] Thread move assignment operator, does not detach previous thread data
-* [@http://svn.boost.org/trac/boost/ticket/11817 #11817] 'sync_queue_is_closed' was not declared in boost/thread/executors/thread_executor.hpp
-* [@http://svn.boost.org/trac/boost/ticket/11818 #11818] future.then will be blocked if promise is set after the invocation of then
-
-
 [heading Version 4.5.0 - boost 1.58]
 
 [*Know Bugs:]

doc/configuration.qbk

@@ -1,5 +1,5 @@
 [/
-  (C) Copyright 2012-2015 Vicente J. Botet Escriba.
+  (C) Copyright 20012 Vicente J. Botet Escriba.
   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).
@@ -23,7 +23,6 @@
     [[PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN] [DONT_PROVIDE_GENERIC_SHARED_MUTEX_ON_WIN]   [NO]  [YES] [YES] ]
 
     [[PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION]    [DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSION]  [NO] [YES] [YES]  ]
-    [[PROVIDES_EXECUTORS]    [-]  [NO] [NO] [NO]  ]
     [[PROVIDES_EXPLICIT_LOCK_CONVERSION]    [DONT_PROVIDE_EXPLICIT_LOCK_CONVERSION]  [NO] [YES] [YES]  ]
     [[PROVIDES_FUTURE]    [DONT_PROVIDE_FUTURE]  [NO] [YES] [YES]  ]
     [[PROVIDES_FUTURE_CTOR_ALLOCATORS]    [DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS]  [NO] [YES] [YES]  ]

doc/emulations.qbk

@@ -260,7 +260,7 @@ Locks provide an explicit bool conversion operator when the compiler provides th
 
 The library provides un implicit conversion to an undefined type that can be used as a conditional expression. 
 
-    #if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+    #if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
         operator ``['unspecified-bool-type]``() const;
         bool operator!() const;
     #else
@@ -346,14 +346,14 @@ use
 
 And instead of
 
-    #ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+    #ifdef BOOST_NO_SCOPED_ENUMS
     template <>
     struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc> : public true_type { };
     #endif
 
 use
 
-    #ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+    #ifdef BOOST_NO_SCOPED_ENUMS
     template <>
     struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc::enum_type> : public true_type { };
     #endif

doc/future_ref.qbk

@@ -1,6 +1,5 @@
 [/
   (C) Copyright 2008-11 Anthony Williams.
-  (C) Copyright 2012-2015 Vicente J. Botet Escriba.
   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).
@@ -29,11 +28,9 @@
 
     enum class launch
     {
-      none = unspecified,
       async = unspecified,
       deferred = unspecified,
       executor = unspecified,
-      inherit = unspecified,
       any = async | deferred
     };
     
@@ -167,27 +164,14 @@
 
     enum class launch
     {
-      none = unspecified,
       async = unspecified,
       deferred = unspecified,
       executor = unspecified,
-      inherit = unspecified,
       any = async | deferred
     };
 
 The enum type launch is a bitmask type with launch::async and launch::deferred denoting individual bits. 
 
-A future created with `promise<>` or with a `packaged_task<>` or with `make_ready_future`/`make_exceptional_future` (has no associated launch policy), has an implicit a launch policy of `launch::none`.
-
-A future created by `async(launch::async, ...)` or `::then(launch::async, ...)` has associated a launch policy `launch::async`.
-A future created by `async(launch::deferred, ...)` or `::then(launch::deferred, ...)` has associated a launch policy `launch::deferred`.
-A future created by `async(Executor, ...)`  or `::then(Executor, ...)` or `::then(launch::executor, ...)` has associated a launch policy `launch::executor`.
-A future created by `async(...)`  or `::then(...)` has associated a launch policy `launch::none`.
-
-A future created by `::then(launch::inherit, ...)` has associated a launch policy parent future.
-
-The `executor` and the `inherit` launch policies have a sense only can be user only on `then()`.
-
 [endsect]
 [///////////////////////////////////////////////////////////////////////////]
 [section:is_error_code_enum Specialization `is_error_code_enum<future_errc>`]
@@ -360,7 +344,7 @@ The object's `name` virtual function returns a pointer to the string "future".]]
       then(F&& func); // EXTENSION
       template<typename S, typename F>
       __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
-      then(Ex& executor, F&& func); // EXTENSION
+      then(S& scheduler, F&& func); // EXTENSION
       template<typename F>
       __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
       then(launch policy, F&& func); // EXTENSION
@@ -900,7 +884,7 @@ associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
       then(F&& func); // EXTENSION
       template<typename S, typename F>
       __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
-      then(Ex& executor, F&& func); // EXTENSION
+      then(S& scheduler, F&& func); // EXTENSION
       template<typename F>
       __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
       then(launch policy, F&& func); // EXTENSION
@@ -913,41 +897,29 @@ There are not too much tests yet, so it is possible that you can find out some t
 [variablelist
 
 [[Notes:] [The three functions differ only by input parameters. The first only takes a callable object which accepts a 
-future object as a parameter. The second function takes a executor as the first parameter and a callable object as 
+future object as a parameter. The second function takes a scheduler as the first parameter and a callable object as 
 the second parameter. The third function takes a launch policy as the first parameter and a callable object as the 
 second parameter.]]
 
-[[Requires:] [`INVOKE(DECAY_COPY (std::forward<F>(func)), std::move(*this))` shall be a valid expression.]]
-
 [[Effects:] [
 
-All the functions create a shared state that is associated with the returned future object. Additionally,
+All the functions create a shared state that is associated with the returned future object. The further behavior of the functions is as follows. 
 
-- When the object's shared state is ready, the continuation
-`INVOKE(DECAY_COPY(std::forward<F>(func)), std::move(*this))` is called depending on the overload (see below) with the call to DECAY_COPY() being evaluated in the thread that called then.
+- The continuation is called when the object's shared state is ready (has a value or exception stored).
 
-- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. 
-Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 
+- The continuation launches according to the specified policy or scheduler.
 
+- When the scheduler or launch policy is not provided the continuation inherits the
+parent's launch policy or scheduler.
 
-The continuation launches according to the specified policy or executor or noting.
+- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 
 
-- When the launch policy is `launch::none` the continuation is called on an unspecified thread of execution.
+- If the parent was created with `promise<>` or with a `packaged_task<>` (has no associated launch policy), the 
+continuation behaves the same as the third overload with a policy argument of `launch::async | launch::deferred` and 
+the same argument for `func`.
 
-- When the launch policy is `launch::async` the continuation is called on a new thread of execution.
-
-- When the launch policy is `launch::deferred` the continuation is called on demand.
-
-- When the launch policy is `launch::executor` the continuation is called on one of the thread of execution of the executor.
-
-- When the launch policy is `launch::inherit` the continuation inherits the parent's launch policy or executor.
-
-- When the executor or launch policy is not provided (first overload) is if as if launch::none was specified.
-
-- When the executor is provided (second overload) the continuation is called on one of the thread of execution of the executor.
-
-- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy
-executor, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
+- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy or 
+scheduler, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
 `launch::deferred`.
 
 ]]
@@ -1389,7 +1361,7 @@ associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
       then(F&& func) const; // EXTENSION
       template<typename S, typename F>
       __unique_future__<typename boost::result_of<F(shared_future)>::type> 
-      then(Ex& executor, F&& func) const; // EXTENSION
+      then(S& scheduler, F&& func) const; // EXTENSION
       template<typename F>
       __unique_future__<typename boost::result_of<F(shared_future)>::type> 
       then(launch policy, F&& func) const; // EXTENSION
@@ -1403,42 +1375,26 @@ There are not too much tests yet, so it is possible that you can find out some t
 [variablelist
 
 [[Notes:] [The three functions differ only by input parameters. The first only takes a callable object which accepts a 
-shared_future object as a parameter. The second function takes an executor as the first parameter and a callable object as 
+shared_future object as a parameter. The second function takes a scheduler as the first parameter and a callable object as 
 the second parameter. The third function takes a launch policy as the first parameter and a callable object as the 
 second parameter.]]
 
-[[Requires:] [`INVOKE(DECAY_COPY (std::forward<F>(func)), *this)` shall be a valid expression.]]
-
 [[Effects:] [
 
-All the functions create a shared state that is associated with the returned future object. Additionally,
+- The continuation is called when the object's shared state is ready (has a value or exception stored).
 
-- When the object's shared state is ready, the continuation
-`INVOKE(DECAY_COPY(std::forward<F>(func)), *this)` is called depending on the overload (see below) with the call to DECAY_COPY() being evaluated in the thread that called then.
+- The continuation launches according to the specified policy or scheduler.
 
-- Any value returned from the continuation is stored as the result in the shared state of the resulting `future`. 
-Any exception propagated from the execution of the continuation is stored as the exceptional result in the shared state of the resulting `future`. 
+- When the scheduler or launch policy is not provided the continuation inherits the
+parent's launch policy or scheduler.
 
+- If the parent was created with `promise` or with a `packaged_task` (has no associated launch policy), the 
+continuation behaves the same as the third overload with a policy argument of `launch::async | launch::deferred` and 
+the same argument for func.
 
-The continuation launches according to the specified policy or executor or noting.
-
-- When the launch policy is `launch::none` the continuation is called on an unspecified thread of execution.
-
-- When the launch policy is `launch::async` the continuation is called on a new thread of execution.
-
-- When the launch policy is `launch::deferred` the continuation is called on demand.
-
-- When the launch policy is `launch::executor` the continuation is called on one of the thread of execution of the executor.
-
-- When the launch policy is `launch::inherit` the continuation inherits the parent's launch policy or executor.
-
-- When the executor or launch policy is not provided (first overload) is if as if launch::none was specified.
-
-- When the executor is provided (second overload) the continuation is called on one of the thread of execution of the executor.
-
-- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy
-executor, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
-`launch::deferred`.
+- If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy or 
+scheduler, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
+`launch::deferred`
 
 ]]
 

doc/futures.qbk

@@ -1,6 +1,5 @@
 [/
   (C) Copyright 2008-11 Anthony Williams.
-  (C) Copyright 2012-2015 Vicente J. Botet Escriba.
   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).
@@ -326,7 +325,7 @@ Using a `shared_future` solves the issue
 
 [heading share()]
   
-Naming the return type when declaring the `shared_future` is needed; auto is not available within template argument lists. 
+Namming the return type when declaring the `shared_future` is needed; auto is not available within template argument lists. 
 Here `share()` could be used to simplify the code
 
   void better_second_use( type arg ) {
@@ -344,7 +343,7 @@ Here `share()` could be used to simplify the code
  
 [heading Writing on get()]
 
-The user can either read or write the future variable. 
+The user can either read or write the future avariable. 
 
   void write_to_get( type arg ) {
       
@@ -365,7 +364,7 @@ The user can either read or write the future variable.
 This works because the `shared_future<>::get()` function returns a non-const reference to the appropriate storage.
 Of course the access to this storage must be ensured by the user. The library doesn't ensure the access to the internal storage is thread safe.
 
-There has been some work by the C++ standard committee on an `atomic_future` that behaves as an `atomic` variable, that is thread_safe, 
+There has been some work by the C++ standard committe on an `atomic_future` that behaves as an `atomic` variable, that is is thread_safe, 
 and a `shared_future` that can be shared between several threads, but there were not enough consensus and time to get it ready for C++11.       
 
 [endsect]
@@ -444,10 +443,10 @@ Input Parameters:
 success and one for error handling. However this option has not been retained for the moment. 
 The lambda function takes a future as its input which carries the exception 
 through. This makes propagating exceptions straightforward. This approach also simplifies the chaining of continuations.
-* Executor: Providing an overload to `.then`, to take an executor reference places great flexibility over the execution 
+* Scheduler: Providing an overload to `.then`, to take a scheduler reference places great flexibility over the execution 
 of the future in the programmer's hand. As described above, often taking a launch policy is not sufficient for powerful 
-asynchronous operations. The lifetime of the executor must outlive the continuation.
-* Launch policy: if the additional flexibility that the executor provides is not required.
+asynchronous operations. The lifetime of the scheduler must outlive the continuation.
+* Launch policy: if the additional flexibility that the scheduler provides is not required.
 
 Return values: The decision to return a future was based primarily on the ability to chain multiple continuations using
 `.then()`. This benefit of composability gives the programmer incredible control and flexibility over their code. Returning 

doc/sync_queues_ref.qbk

@@ -110,10 +110,10 @@ where
 * `q` denotes a value of type `Q`, 
 * `e` denotes a value of type Q::value_type, 
 * `u` denotes a value of type Q::size_type, 
-* `lve` denotes an lvalue reference of type Q::value_type, 
-* `rve` denotes an rvalue reference of type Q::value_type:
+* `lve` denotes a lvalue referece of type Q::value_type, 
+* `rve` denotes a rvalue referece of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]
-* `qs` denotes a variable of of type `queue_op_status`, 
+* `qs` denotes a variable of of type `queus_op_status`, 
 
 
 [/////////////////////////////////////]
@@ -246,8 +246,8 @@ where
 * `e` denotes a value of type `Q::value_type`, 
 * `s` denotes a value of type `queue_status`, 
 * `u` denotes a value of type `Q::size_type`, 
-* `lve` denotes an lvalue reference of type Q::value_type, 
-* `rve` denotes an rvalue reference of type Q::value_type:
+* `lve` denotes a lvalue referece of type Q::value_type, 
+* `rve` denotes a rvalue referece of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]
 
 
@@ -357,8 +357,8 @@ where
 * `q` denotes a value of type `Q`, 
 * `e` denotes a value of type Q::value_type, 
 * `s` denotes a value of type `queue_status`, 
-* `lve` denotes an lvalue reference of type Q::value_type, 
-* `rve` denotes an rvalue reference of type Q::value_type:
+* `lve` denotes a lvalue referece of type Q::value_type, 
+* `rve` denotes a rvalue referece of type Q::value_type:
 [/* `spe` denotes a shared_ptr<Q::value_type>]
 
 
@@ -545,7 +545,7 @@ Closed queues add the following valid expressions
 
 [[Return:] [
 
-- If the queue is closed return `queue_op_status::closed`,
+- If the queue is closed retun `queue_op_status::closed`,
 
 - otherwise, return `queue_op_status::success` if no exception is thrown.
 

doc/sync_tutorial.qbk

@@ -7,10 +7,8 @@
 
 [section:tutorial Tutorial]
 
-
 [@http://web.archive.org/web/20140531071228/http://home.roadrunner.com/~hinnant/mutexes/locking.html Handling mutexes in C++] is an excellent tutorial. You need just replace std and ting by boost.
 
-
 [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2406.html Mutex, Lock, Condition Variable Rationale] adds rationale for the design decisions made for mutexes, locks and condition variables.
 
 

doc/thread.qbk

@@ -8,7 +8,7 @@
 
 [library Thread
     [quickbook 1.5]
-    [version 4.6.0]
+    [version 4.5.0]
     [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
     [copyright 2007-11 Anthony Williams]
     [copyright 2011-15 Vicente J. Botet Escriba]

doc/thread_ref.qbk

@@ -255,7 +255,7 @@ does not complete when the specified time has elapsed or reached respectively.
 
 [endsect]
 
-[section:destructor1 Destructor V1-2]
+[section:destructor1 Destructor V1]
 
 When the __thread__ object that represents a thread of execution is destroyed the thread becomes ['detached]. Once a thread is
 detached, it will continue executing until the invocation of the function or callable object supplied on construction has completed,
@@ -264,7 +264,7 @@ object. In this case, the __thread__ object ceases to represent the now-detached
 
 [endsect]
 
-[section:destructor2 Destructor V3-X]
+[section:destructor2 Destructor V2]
 
 When the __thread__ object that represents a thread of execution is destroyed the program terminates if the thread is __joinable__. 
 
@@ -280,7 +280,7 @@ You can use a thread_joiner to ensure that the thread has been joined at the thr
   {
     boost::thread t(my_func);
     boost::thread_joiner g(t);
-    // do something else
+    // do someting else
   } // here the thread_joiner destructor will join the thread before it is destroyed.
 
 [endsect]
@@ -410,7 +410,7 @@ Of course all the synchronization facilities provided by Boost.Thread are also a
 
 The `boost::this_thread` interrupt related functions behave in a degraded mode when called from a thread created using the native interface, i.e. `boost::this_thread::interruption_enabled()` returns false. As consequence the use of `boost::this_thread::disable_interruption` and `boost::this_thread::restore_interruption` will do nothing and calls to `boost::this_thread::interruption_point()` will be just ignored.  
 
-As the single way to interrupt a thread is through a __thread__ instance, `interruption_request()` will return false for the native threads. 
+As the single way to interrupt a thread is through a __thread__ instance, `interruption_request()` wiil returns false for the native threads. 
 
 [heading `pthread_exit` POSIX limitation]
 
@@ -964,7 +964,7 @@ predefined __interruption_points__ with interruption enabled .]]
 
 [section:hardware_concurrency Static member function `hardware_concurrency()`]
 
-    unsigned hardware_concurrency() noexcept;
+    unsigned hardware_concurrency() noexecpt;
 
 [variablelist
 
@@ -979,7 +979,7 @@ or 0 if this information is not available.]]
 
 [section:physical_concurrency Static member function `physical_concurrency()`]
 
-    unsigned physical_concurrency() noexcept;
+    unsigned physical_concurrency() noexecpt;
 
 [variablelist
 
@@ -1290,7 +1290,7 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `
 
 [variablelist
 
-[[Effects:] [Constructs a thread attributes instance with its default values.]]
+[[Effects:] [Constructs a thread atrributes instance with its default values.]]
 
 [[Throws:] [Nothing]]
 
@@ -1532,7 +1532,7 @@ do not throw exceptions. __thread_interrupted__ if the current thread of executi
 
 [variablelist
 
-[[Effects:] [Suspends the current thread until the duration specified
+[[Effects:] [Suspends the current thread until the duration specified by
 by `rel_time` has elapsed.]]
 
 [[Throws:] [Nothing if operations of chrono::duration<Rep, Period> do not throw exceptions. __thread_interrupted__ if the current thread of execution is interrupted.]]

example/executor.cpp

@@ -7,7 +7,6 @@
 #if ! defined  BOOST_NO_CXX11_DECLTYPE
 #define BOOST_RESULT_OF_USE_DECLTYPE
 #endif
-#include <iostream>
 
 #define BOOST_THREAD_VERSION 4
 #define BOOST_THREAD_PROVIDES_EXECUTORS
@@ -18,7 +17,7 @@
 #include <boost/thread/caller_context.hpp>
 #include <boost/thread/executors/basic_thread_pool.hpp>
 #include <boost/thread/executors/loop_executor.hpp>
-#include <boost/thread/executors/serial_executor.hpp>
+#include <boost/thread/executors/generic_serial_executor.hpp>
 #include <boost/thread/executors/inline_executor.hpp>
 #include <boost/thread/executors/thread_executor.hpp>
 #include <boost/thread/executors/executor.hpp>
@@ -49,9 +48,8 @@ void p2()
 
 int f1()
 {
-  std::cout << BOOST_CONTEXTOF << std::endl;
+  // std::cout << BOOST_CONTEXTOF << std::endl;
   boost::this_thread::sleep_for(boost::chrono::seconds(1));
-  std::cout << BOOST_CONTEXTOF << std::endl;
   return 1;
 }
 int f2(int i)
@@ -73,102 +71,112 @@ void submit_some(boost::executor& tp)
 }
 
 
-void at_th_entry(boost::basic_thread_pool& )
+void at_th_entry(boost::basic_thread_pool )
 {
 
 }
 
 int test_executor_adaptor()
 {
-  std::cout << BOOST_CONTEXTOF << std::endl;
+  // std::cout << BOOST_CONTEXTOF << std::endl;
   {
     try
     {
+      {
+        boost::basic_thread_pool e1;
+        boost::basic_thread_pool e2 = e1;
+      }
       {
         boost::executor_adaptor < boost::basic_thread_pool > ea(4);
-        std::cout << BOOST_CONTEXTOF << std::endl;
         submit_some( ea);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-#if 1
-      // fixme
-      // ERROR= tr1::bad_weak_ptr
         {
           boost::future<int> t1 = boost::async(ea, &f1);
           boost::future<int> t2 = boost::async(ea, &f1);
-          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
         }
-        std::cout << BOOST_CONTEXTOF << std::endl;
         submit_some(ea);
-        std::cout << BOOST_CONTEXTOF << std::endl;
         {
           boost::basic_thread_pool ea3(1);
-          std::cout << BOOST_CONTEXTOF << std::endl;
           boost::future<int> t1 = boost::async(ea3, &f1);
-          std::cout << BOOST_CONTEXTOF << std::endl;
           boost::future<int> t2 = boost::async(ea3, &f1);
-          std::cout << BOOST_CONTEXTOF << std::endl;
           //boost::future<int> t2 = boost::async(ea3, f2, 1); // todo this doesn't compiles yet on C++11
           //boost::future<int> t2 = boost::async(ea3, boost::bind(f2, 1)); // todo this doesn't compiles yet on C++98
-          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
         }
-#endif
-        std::cout << BOOST_CONTEXTOF << std::endl;
         submit_some(ea);
-        std::cout << BOOST_CONTEXTOF << std::endl;
       }
-      std::cout << BOOST_CONTEXTOF << std::endl;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::loop_executor e1;
+        boost::loop_executor e2 = e1;
+        boost::executor_adaptor < boost::loop_executor > ea2(e2);
+        submit_some( ea2);
+        ea2.underlying_executor().run_queued_closures();
+      }
       {
         boost::executor_adaptor < boost::loop_executor > ea2;
         submit_some( ea2);
         ea2.underlying_executor().run_queued_closures();
       }
-#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      std::cout << BOOST_CONTEXTOF << std::endl;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
-        boost::executor_adaptor < boost::basic_thread_pool > ea1(4);
-        boost::executor_adaptor < boost::serial_executor > ea2(ea1);
+        boost::basic_thread_pool tp;
+        boost::generic_serial_executor e1(tp);
+        boost::generic_serial_executor e2 = e1;
+      }
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::generic_serial_executor ea2(ea1);
+        boost::executor_adaptor < boost::generic_serial_executor > ea3(ea2);
+        submit_some(ea3);
+      }
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::generic_serial_executor ea2(ea1);
+        boost::executor_adaptor < boost::generic_serial_executor > ea3(ea2);
+        submit_some(ea3);
+      }
+//#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::executor_adaptor < boost::generic_serial_executor > ea2(ea1);
+        submit_some(ea2);
+      }
+//#endif
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::inline_executor e1;
+        boost::inline_executor e2 = e1;
+        boost::executor_adaptor < boost::inline_executor > ea2(e2);
         submit_some(ea2);
       }
-#endif
-      std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::executor_adaptor < boost::inline_executor > ea1;
         submit_some(ea1);
       }
-      std::cout << BOOST_CONTEXTOF << std::endl;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::thread_executor e1;
+        boost::thread_executor e2 = e1;
+      }
+      {
+        boost::thread_executor e1;
+        boost::executor_adaptor < boost::generic_executor > ea2(e1);
+        submit_some(ea2);
+      }
+
       {
         boost::executor_adaptor < boost::thread_executor > ea1;
         submit_some(ea1);
       }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-#if 1
-      // fixme
-      // ERROR= tr1::bad_weak_ptr
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::basic_thread_pool  ea(4, at_th_entry);
         boost::future<int> t1 = boost::async(ea, &f1);
-        std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+        // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
       }
-#endif
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::async(&f1);
-      }
-#if 1
-      // fixme
-      // ERROR= tr1::bad_weak_ptr
-
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::basic_thread_pool  ea(1);
-        boost::async(ea,&f1);
-      }
-#endif
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-      std::cout << BOOST_CONTEXTOF << std::endl;
     }
     catch (std::exception& ex)
     {
@@ -190,7 +198,7 @@ int main()
 {
   return test_executor_adaptor();
 
-#if 0 && defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION \
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION \
   && defined BOOST_THREAD_PROVIDES_EXECUTORS \
   &&  ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
 

example/future_unwrap.cpp

@@ -41,28 +41,10 @@ int main()
   for (int i=0; i< number_of_tests; i++)
   try
   {
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    {
-      boost::future<int> inner_future = boost::async(boost::launch::async, &p2);
-      inner_future.wait();
-      int ii = inner_future.get();
-      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
-    }
-#endif
-    {
-      boost::future<boost::future<int> > outer_future = boost::async(boost::launch::async, &p2);
-      boost::future<int> inner_future = outer_future.unwrap();
-      inner_future.wait();
-      int ii = inner_future.get();
-      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
-    }
-    {
-      boost::future<boost::future<int> > outer_future = boost::async(boost::launch::async, &p2);
-      boost::future<int> inner_future = outer_future.unwrap();
-      int ii = inner_future.get();
-      BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
-    }
+    boost::future<boost::future<int> > outer_future = boost::async(boost::launch::async, &p2);
+    boost::future<int> inner_future = outer_future.unwrap();
+    int ii = inner_future.get();
+    BOOST_THREAD_LOG << "ii= "<< ii << "" << BOOST_THREAD_END_LOG;
   }
   catch (std::exception& ex)
   {

example/future_when_all.cpp

@@ -58,8 +58,6 @@ int p2(boost::future<int> f)
   }
   BOOST_THREAD_LOG
     << "P2>" << BOOST_THREAD_END_LOG;
-  return 0;
-
 }
 int p2s(boost::shared_future<int> f)
 {
@@ -83,7 +81,6 @@ int p2s(boost::shared_future<int> f)
   }
   BOOST_THREAD_LOG
     << "P2>" << BOOST_THREAD_END_LOG;
-  return 0;
 }
 
 int main()

example/generic_executor.cpp

@@ -0,0 +1,184 @@
+// Copyright (C) 2014 Vicente Botet
+//
+//  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 <boost/config.hpp>
+#if ! defined  BOOST_NO_CXX11_DECLTYPE
+#define BOOST_RESULT_OF_USE_DECLTYPE
+#endif
+
+#define BOOST_THREAD_VERSION 4
+#define BOOST_THREAD_PROVIDES_EXECUTORS
+//#define BOOST_THREAD_USES_LOG
+#define BOOST_THREAD_USES_LOG_THREAD_ID
+#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
+
+#include <boost/thread/caller_context.hpp>
+#include <boost/thread/executors/basic_thread_pool.hpp>
+#include <boost/thread/executors/loop_executor.hpp>
+#include <boost/thread/executors/generic_serial_executor.hpp>
+#include <boost/thread/executors/serial_executor.hpp>
+#include <boost/thread/executors/inline_executor.hpp>
+#include <boost/thread/executors/thread_executor.hpp>
+#include <boost/thread/executors/executor.hpp>
+#include <boost/thread/executors/executor_adaptor.hpp>
+#include <boost/thread/executors/generic_executor.hpp>
+#include <boost/thread/executor.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/assert.hpp>
+#include <string>
+#include <iostream>
+
+void p1()
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  //boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
+}
+
+void p2()
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  //boost::this_thread::sleep_for(boost::chrono::seconds(10));
+}
+
+int f1()
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::seconds(1));
+  return 1;
+}
+int f2(int i)
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::seconds(2));
+  return i + 1;
+}
+
+void submit_some(boost::generic_executor tp)
+{
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p2);
+  }
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p1);
+  }
+
+}
+
+template < class Executor>
+void submit_some2(Executor& tp)
+{
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p2);
+  }
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p1);
+  }
+
+}
+
+template <class Executor>
+void submit_some3(boost::serial_executor<Executor>& tp)
+{
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p2);
+  }
+  for (int i = 0; i < 3; ++i) {
+    tp.submit(&p1);
+  }
+}
+
+void at_th_entry(boost::basic_thread_pool)
+{
+
+}
+
+
+
+int test_generic_executor()
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  {
+    try
+    {
+      {
+        boost::basic_thread_pool ea(4);
+        submit_some( ea);
+        {
+          boost::future<int> t1 = boost::async(ea, &f1);
+          boost::future<int> t2 = boost::async(ea, &f1);
+          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+        }
+        submit_some(ea);
+        {
+          boost::basic_thread_pool ea3(1);
+          boost::future<int> t1 = boost::async(ea3, &f1);
+          boost::future<int> t2 = boost::async(ea3, &f1);
+          //boost::future<int> t2 = boost::async(ea3, f2, 1); // todo this doesn't compiles yet on C++11
+          //boost::future<int> t2 = boost::async(ea3, boost::bind(f2, 1)); // todo this doesn't compiles yet on C++98
+          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+        }
+        submit_some(ea);
+      }
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::loop_executor ea2;
+        submit_some( ea2);
+        ea2.run_queued_closures();
+      }
+#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+//      // std::cout << BOOST_CONTEXTOF << std::endl;
+//      {
+//        boost::basic_thread_pool ea1(4);
+//        boost::generic_serial_executor ea2(ea1);
+//        submit_some(ea2);
+//      }
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::serial_executor<boost::basic_thread_pool> ea2(ea1);
+        submit_some3(ea2);
+      }
+#endif
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::inline_executor ea1;
+        submit_some(ea1);
+      }
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        //boost::thread_executor ea1;
+        //submit_some(ea1);
+      }
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::basic_thread_pool  ea(4, at_th_entry);
+        boost::future<int> t1 = boost::async(ea, &f1);
+        // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+      }
+    }
+    catch (std::exception& ex)
+    {
+      std::cout << "ERROR= " << ex.what() << "" << std::endl;
+      return 1;
+    }
+    catch (...)
+    {
+      std::cout << " ERROR= exception thrown" << std::endl;
+      return 2;
+    }
+  }
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  return 0;
+}
+
+
+int main()
+{
+  return test_generic_executor();
+
+
+}

example/generic_executor_ref.cpp

@@ -17,11 +17,12 @@
 #include <boost/thread/caller_context.hpp>
 #include <boost/thread/executors/basic_thread_pool.hpp>
 #include <boost/thread/executors/loop_executor.hpp>
-#include <boost/thread/executors/serial_executor.hpp>
+#include <boost/thread/executors/generic_serial_executor.hpp>
 #include <boost/thread/executors/inline_executor.hpp>
 #include <boost/thread/executors/thread_executor.hpp>
 #include <boost/thread/executors/executor.hpp>
 #include <boost/thread/executors/executor_adaptor.hpp>
+#include <boost/thread/executors/generic_executor_ref.hpp>
 #include <boost/thread/executor.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/assert.hpp>
@@ -64,7 +65,7 @@ void submit_some(boost::generic_executor_ref tp)
 
 }
 
-void at_th_entry(boost::basic_thread_pool& )
+void at_th_entry(boost::basic_thread_pool)
 {
 
 }
@@ -73,7 +74,7 @@ void at_th_entry(boost::basic_thread_pool& )
 
 int test_generic_executor_ref()
 {
-  std::cout << BOOST_CONTEXTOF << std::endl;
+  // std::cout << BOOST_CONTEXTOF << std::endl;
   {
     try
     {
@@ -83,8 +84,8 @@ int test_generic_executor_ref()
         {
           boost::future<int> t1 = boost::async(ea, &f1);
           boost::future<int> t2 = boost::async(ea, &f1);
-          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
         }
         submit_some(ea);
         {
@@ -93,51 +94,41 @@ int test_generic_executor_ref()
           boost::future<int> t2 = boost::async(ea3, &f1);
           //boost::future<int> t2 = boost::async(ea3, f2, 1); // todo this doesn't compiles yet on C++11
           //boost::future<int> t2 = boost::async(ea3, boost::bind(f2, 1)); // todo this doesn't compiles yet on C++98
-          std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
-          std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+          // std::cout << BOOST_CONTEXTOF << " t2= " << t2.get() << std::endl;
         }
         submit_some(ea);
       }
-      std::cout << BOOST_CONTEXTOF << std::endl;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::loop_executor ea2;
         submit_some( ea2);
         ea2.run_queued_closures();
       }
 #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      std::cout << BOOST_CONTEXTOF << std::endl;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::basic_thread_pool ea1(4);
-        boost::serial_executor ea2(ea1);
+        boost::generic_serial_executor ea2(ea1);
         submit_some(ea2);
       }
 #endif
-      std::cout << BOOST_CONTEXTOF << std::endl;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::inline_executor ea1;
         submit_some(ea1);
       }
-      std::cout << BOOST_CONTEXTOF << std::endl;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         //boost::thread_executor ea1;
         //submit_some(ea1);
       }
-      std::cout << BOOST_CONTEXTOF << std::endl;
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::basic_thread_pool  ea(4, at_th_entry);
         boost::future<int> t1 = boost::async(ea, &f1);
-        std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
+        // std::cout << BOOST_CONTEXTOF << " t1= " << t1.get() << std::endl;
       }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      {
-        boost::basic_thread_pool  ea(4, at_th_entry);
-        boost::async(ea, &f1);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-      }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-      boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
-      std::cout << BOOST_CONTEXTOF << std::endl;
-
     }
     catch (std::exception& ex)
     {

example/generic_serial_executor.cpp

@@ -0,0 +1,117 @@
+// Copyright (C) 2015 Vicente J. Botet Escriba
+//
+//  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 <boost/config.hpp>
+#if ! defined  BOOST_NO_CXX11_DECLTYPE
+#define BOOST_RESULT_OF_USE_DECLTYPE
+#endif
+
+#define BOOST_THREAD_VERSION 4
+#define BOOST_THREAD_PROVIDES_EXECUTORS
+//#define BOOST_THREAD_USES_LOG
+#define BOOST_THREAD_USES_LOG_THREAD_ID
+#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
+
+#include <boost/thread/caller_context.hpp>
+#include <boost/thread/executors/basic_thread_pool.hpp>
+#include <boost/thread/executors/generic_serial_executor.hpp>
+#include <boost/thread/executors/executor.hpp>
+#include <boost/thread/executors/executor_adaptor.hpp>
+#include <boost/thread/executor.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/assert.hpp>
+#include <string>
+#include <iostream>
+
+void p1()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(30));
+  std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+void p2()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
+  std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+int f1()
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::seconds(1));
+  return 1;
+}
+int f2(int i)
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::seconds(2));
+  return i + 1;
+}
+
+void submit_some(boost::generic_serial_executor& tp)
+{
+  //std::cout << BOOST_CONTEXTOF << std::endl;
+  for (int i = 0; i < 3; ++i) {
+    //std::cout << BOOST_CONTEXTOF << std::endl;
+    tp.submit(&p2);
+  }
+  for (int i = 0; i < 3; ++i) {
+    //std::cout << BOOST_CONTEXTOF << std::endl;
+    tp.submit(&p1);
+  }
+  //std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+
+void at_th_entry(boost::basic_thread_pool )
+{
+
+}
+
+int test_executor_adaptor()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  {
+     boost::basic_thread_pool tp;
+     boost::generic_serial_executor e1(tp);
+     boost::generic_serial_executor e2 = e1;
+  }
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  {
+    try
+    {
+
+#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::generic_serial_executor ea2(ea1);
+        submit_some(ea2);
+      }
+#endif
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+    }
+    catch (std::exception& ex)
+    {
+      std::cout << "ERROR= " << ex.what() << "" << std::endl;
+      return 1;
+    }
+    catch (...)
+    {
+      std::cout << " ERROR= exception thrown" << std::endl;
+      return 2;
+    }
+  }
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  return 0;
+}
+
+
+int main()
+{
+  return test_executor_adaptor();
+}

example/generic_serial_executor_cont.cpp

@@ -0,0 +1,118 @@
+// Copyright (C) 2015 Vicente J. Botet Escriba
+//
+//  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 <boost/config.hpp>
+#if ! defined  BOOST_NO_CXX11_DECLTYPE
+#define BOOST_RESULT_OF_USE_DECLTYPE
+#endif
+
+#define BOOST_THREAD_VERSION 4
+#define BOOST_THREAD_PROVIDES_EXECUTORS
+//#define BOOST_THREAD_USES_LOG
+#define BOOST_THREAD_USES_LOG_THREAD_ID
+#define BOOST_THREAD_QUEUE_DEPRECATE_OLD
+
+#include <boost/thread/caller_context.hpp>
+#include <boost/thread/executors/basic_thread_pool.hpp>
+#include <boost/thread/executors/generic_serial_executor_cont.hpp>
+#include <boost/thread/executors/executor.hpp>
+#include <boost/thread/executors/executor_adaptor.hpp>
+#include <boost/thread/executor.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/assert.hpp>
+#include <string>
+#include <iostream>
+
+void p1()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(30));
+  std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+void p2()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
+  std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+int f1()
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::seconds(1));
+  return 1;
+}
+int f2(int i)
+{
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::seconds(2));
+  return i + 1;
+}
+
+void submit_some(boost::generic_serial_executor_cont& tp)
+{
+  //std::cout << BOOST_CONTEXTOF << std::endl;
+  for (int i = 0; i < 3; ++i) {
+    //std::cout << BOOST_CONTEXTOF << std::endl;
+    tp.submit(&p2);
+  }
+  for (int i = 0; i < 3; ++i) {
+    //std::cout << BOOST_CONTEXTOF << std::endl;
+    tp.submit(&p1);
+  }
+  //std::cout << BOOST_CONTEXTOF << std::endl;
+
+}
+
+
+void at_th_entry(boost::basic_thread_pool)
+{
+
+}
+
+int test_executor_adaptor()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  {
+     boost::basic_thread_pool tp;
+     boost::generic_serial_executor_cont e1(tp);
+     boost::generic_serial_executor_cont e2 = e1;
+  }
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  {
+    try
+    {
+
+#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+      {
+        boost::basic_thread_pool ea1(4);
+        boost::generic_serial_executor_cont ea2(ea1);
+        submit_some(ea2);
+      }
+#endif
+      // std::cout << BOOST_CONTEXTOF << std::endl;
+    }
+    catch (std::exception& ex)
+    {
+      std::cout << "ERROR= " << ex.what() << "" << std::endl;
+      return 1;
+    }
+    catch (...)
+    {
+      std::cout << " ERROR= exception thrown" << std::endl;
+      return 2;
+    }
+  }
+  // std::cout << BOOST_CONTEXTOF << std::endl;
+  return 0;
+}
+
+
+int main()
+{
+  return test_executor_adaptor();
+}

example/serial_executor.cpp

@@ -51,8 +51,8 @@ int f2(int i)
   boost::this_thread::sleep_for(boost::chrono::seconds(2));
   return i + 1;
 }
-
-void submit_some(boost::serial_executor& tp)
+template <class Executor>
+void submit_some(boost::serial_executor<Executor>& tp)
 {
   for (int i = 0; i < 3; ++i) {
     std::cout << BOOST_CONTEXTOF << std::endl;
@@ -80,9 +80,8 @@ int test_executor_adaptor()
 #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       {
         boost::basic_thread_pool ea1(4);
-        boost::serial_executor ea2(ea1);
+        boost::serial_executor<boost::basic_thread_pool> ea2(ea1);
         submit_some(ea2);
-        boost::this_thread::sleep_for(boost::chrono::seconds(10));
       }
 #endif
     }

example/serial_executor_cont.cpp

@@ -52,18 +52,19 @@ int f2(int i)
   return i + 1;
 }
 
-void submit_some(boost::serial_executor_cont& tp)
+template < class Executor>
+void submit_some(boost::serial_executor_cont<Executor>& tp)
 {
-  std::cout << BOOST_CONTEXTOF << std::endl;
+  //std::cout << BOOST_CONTEXTOF << std::endl;
   for (int i = 0; i < 3; ++i) {
-    std::cout << BOOST_CONTEXTOF << std::endl;
+    //std::cout << BOOST_CONTEXTOF << std::endl;
     tp.submit(&p2);
   }
   for (int i = 0; i < 3; ++i) {
-    std::cout << BOOST_CONTEXTOF << std::endl;
+    //std::cout << BOOST_CONTEXTOF << std::endl;
     tp.submit(&p1);
   }
-  std::cout << BOOST_CONTEXTOF << std::endl;
+  //std::cout << BOOST_CONTEXTOF << std::endl;
 
 }
 
@@ -84,9 +85,8 @@ int test_executor_adaptor()
       // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::basic_thread_pool ea1(4);
-        boost::serial_executor_cont ea2(ea1);
+        boost::serial_executor_cont<boost::basic_thread_pool> ea2(ea1);
         submit_some(ea2);
-        boost::this_thread::sleep_for(boost::chrono::seconds(10));
       }
 #endif
       // std::cout << BOOST_CONTEXTOF << std::endl;

example/tennis.cpp

@@ -39,7 +39,7 @@ const char* player_name(int state)
     if (state == PLAYER_B)
         return "PLAYER-B";
     throw "bad player";
-    //return 0;
+    return 0;
 }
 
 void player(int active)
@@ -50,7 +50,7 @@ void player(int active)
 
     while (state < GAME_OVER)
     {
-        //std::cout << player_name(active) << ": Play." << std::endl;
+        std::cout << player_name(active) << ": Play." << std::endl;
         state = other;
         cond.notify_all();
         do

example/tss.cpp

@@ -24,7 +24,6 @@ void thread_proc()
         increment();
         int* p = value.get();
         assert(*p == i+1);
-        (void)(p);
     }
 }
 

include/boost/thread/concurrent_queues/sync_queue.hpp

@@ -10,7 +10,6 @@
 // See http://www.boost.org/libs/thread for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
-#include <iostream>
 
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/concurrent_queues/detail/sync_queue_base.hpp>
@@ -151,19 +150,13 @@ namespace concurrent
   template <class ValueType, class Container>
   queue_op_status sync_queue<ValueType, Container>::wait_pull(ValueType& elem, unique_lock<mutex>& lk)
   {
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     if (super::empty(lk))
     {
-      //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
       if (super::closed(lk)) return queue_op_status::closed;
     }
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     bool has_been_closed = super::wait_until_not_empty_or_closed(lk);
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     if (has_been_closed) return queue_op_status::closed;
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     pull(elem, lk);
-    //std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     return queue_op_status::success;
   }
 

include/boost/thread/concurrent_queues/sync_timed_queue.hpp

@@ -235,7 +235,7 @@ namespace detail
       if (super::closed(lk)) return true;
       super::not_empty_.wait(lk);
     }
-    //return false;
+    return false;
   }
 
   ///////////////////////////

include/boost/thread/csbl/devector.hpp

@@ -21,8 +21,8 @@ namespace boost
     template <class T>
     class devector
     {
-      typedef csbl::vector<T> vector_type;
-      vector_type data_;
+      typedef vector<T> vector_type;
+      vector<T> data_;
       std::size_t front_index_;
 
       BOOST_COPYABLE_AND_MOVABLE(devector)
@@ -58,9 +58,7 @@ namespace boost
       }
 
       devector& operator=(BOOST_RV_REF(devector) x)
-#if defined BOOST_THREAD_USES_BOOST_VECTOR
-         BOOST_NOEXCEPT_IF(vector_type::allocator_traits_type::propagate_on_container_move_assignment::value)
-#endif
+         BOOST_NOEXCEPT_IF(vector<T>::allocator_traits_type::propagate_on_container_move_assignment::value)
       {
         data_ = boost::move(x.data_);
         front_index_ = x.front_index_;

include/boost/thread/detail/invoker.hpp

@@ -72,21 +72,13 @@ namespace boost
       BOOST_SYMBOL_VISIBLE
       invoker& operator=(BOOST_THREAD_RV_REF(invoker) f)
       {
-        if (this != &f)
-        {
-          f_ = boost::move(BOOST_THREAD_RV(f).f_);
-        }
-        return *this;
+        f_ = boost::move(BOOST_THREAD_RV(f).f_);
       }
 
       BOOST_SYMBOL_VISIBLE
       invoker& operator=( BOOST_THREAD_COPY_ASSIGN_REF(invoker) f)
       {
-        if (this != &f)
-        {
-          f_ = f.f_;
-        }
-        return *this;
+        f_ = f.f_;
       }
 
       result_type operator()()
@@ -99,7 +91,7 @@ namespace boost
       result_type
       execute(tuple_indices<Indices...>)
       {
-        return detail::invoke(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
+        return invoke(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
       }
     };
 
@@ -136,7 +128,7 @@ namespace boost
       result_type
       execute(tuple_indices<Indices...>)
       {
-        return detail::invoke<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
+        return invoke<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
       }
     };
   //BOOST_THREAD_DCL_MOVABLE_BEG(X) invoker<Fp> BOOST_THREAD_DCL_MOVABLE_END
@@ -190,7 +182,7 @@ namespace boost
       {} \
       \
       result_type operator()() { \
-        return detail::invoke(boost::move(fp_) \
+        return invoke(boost::move(fp_) \
             BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL, ~) \
         ); \
       } \
@@ -315,7 +307,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -381,7 +373,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -442,7 +434,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -498,7 +490,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -549,7 +541,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -595,7 +587,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -636,7 +628,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
             , boost::move(v2_)
@@ -672,7 +664,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
             , boost::move(v1_)
         );
@@ -703,7 +695,7 @@ namespace boost
 
       result_type operator()()
       {
-        return detail::invoke(boost::move(fp_)
+        return invoke(boost::move(fp_)
             , boost::move(v0_)
         );
       }

include/boost/thread/detail/move.hpp

@@ -94,11 +94,6 @@ namespace boost
     template <typename T> \
     struct enable_move_utility_emulation_dummy_specialization<
 
-#define BOOST_THREAD_DCL_MOVABLE_BEG2(T1, T2) \
-  namespace detail { \
-    template <typename T1, typename T2> \
-    struct enable_move_utility_emulation_dummy_specialization<
-
 #define BOOST_THREAD_DCL_MOVABLE_END > \
       : integral_constant<bool, false> \
       {}; \
@@ -120,11 +115,6 @@ namespace boost
     template <typename T> \
     struct enable_move_utility_emulation_dummy_specialization<
 
-#define BOOST_THREAD_DCL_MOVABLE_BEG2(T1, T2) \
-  namespace detail { \
-    template <typename T1, typename T2> \
-    struct enable_move_utility_emulation_dummy_specialization<
-
 #define BOOST_THREAD_DCL_MOVABLE_END > \
       : integral_constant<bool, false> \
       {}; \
@@ -146,11 +136,6 @@ namespace boost
     template <typename T> \
     struct enable_move_utility_emulation_dummy_specialization<
 
-#define BOOST_THREAD_DCL_MOVABLE_BEG2(T1, T2) \
-  namespace detail { \
-    template <typename T1, typename T2> \
-    struct enable_move_utility_emulation_dummy_specialization<
-
 #define BOOST_THREAD_DCL_MOVABLE_END > \
       : integral_constant<bool, false> \
       {}; \
@@ -176,10 +161,6 @@ struct enable_move_utility_emulation< TYPE > \
 template <typename T> \
 struct enable_move_utility_emulation<
 
-#define BOOST_THREAD_DCL_MOVABLE_BEG2(T1, T2) \
-template <typename T1, typename T2> \
-struct enable_move_utility_emulation<
-
 #define BOOST_THREAD_DCL_MOVABLE_END > \
 { \
    static const bool value = false; \

include/boost/thread/detail/nullary_function.hpp

@@ -228,7 +228,7 @@ namespace boost
 
     };
   }
-  BOOST_THREAD_DCL_MOVABLE_BEG(F) detail::nullary_function<F> BOOST_THREAD_DCL_MOVABLE_END
+  //BOOST_THREAD_DCL_MOVABLE_BEG(F) detail::nullary_function<F> BOOST_THREAD_DCL_MOVABLE_END
 }
 
 #endif // header

include/boost/thread/detail/thread.hpp

@@ -72,7 +72,7 @@ namespace boost
           void run2(tuple_indices<Indices...>)
           {
 
-              detail::invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...);
+              invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...);
           }
           void run()
           {
@@ -354,8 +354,6 @@ namespace boost
 
 #if defined BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE
             if (joinable()) std::terminate();
-#else
-            detach();
 #endif
             thread_info=BOOST_THREAD_RV(other).thread_info;
             BOOST_THREAD_RV(other).thread_info.reset();
@@ -486,9 +484,9 @@ namespace boost
         bool try_join_until(const chrono::time_point<Clock, Duration>& t)
         {
           using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
           bool joined= false;
           do {
-            system_clock::time_point     s_now = system_clock::now();
             typename Clock::duration   d = ceil<nanoseconds>(t-Clock::now());
             if (d <= Clock::duration::zero()) return false; // in case the Clock::time_point t is already reached
             joined = try_join_until(s_now + d);

include/boost/thread/detail/thread_group.hpp

@@ -6,7 +6,6 @@
 // (C) Copyright 2007-9 Anthony Williams
 
 #include <list>
-#include <boost/thread/csbl/memory/unique_ptr.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/lock_guard.hpp>
@@ -76,7 +75,7 @@ namespace boost
         thread* create_thread(F threadfunc)
         {
             boost::lock_guard<shared_mutex> guard(m);
-            boost::csbl::unique_ptr<thread> new_thread(new thread(threadfunc));
+            std::auto_ptr<thread> new_thread(new thread(threadfunc));
             threads.push_back(new_thread.get());
             return new_thread.release();
         }

include/boost/thread/executors/basic_thread_pool.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2013-2014 Vicente J. Botet Escriba
+// Copyright (C) 2013-2015 Vicente J. Botet Escriba
 //
 //  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)
@@ -18,6 +18,11 @@
 #include <boost/thread/executors/work.hpp>
 #include <boost/thread/csbl/vector.hpp>
 
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/smart_ptr/enable_shared_from_this.hpp>
+#include <boost/function.hpp>
+
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
@@ -30,126 +35,256 @@ namespace executors
     /// type-erasure to store the works to do
     typedef  executors::work work;
   private:
-    typedef thread thread_t;
-    /// A move aware vector type
-    typedef csbl::vector<thread_t> thread_vector;
 
-    /// A move aware vector
-    thread_vector threads;
-    /// the thread safe work queue
-    concurrent::sync_queue<work > work_queue;
+    struct shared_state : enable_shared_from_this<shared_state> {
+      typedef  executors::work work;
+      /// the kind of stored threads are scoped threads to ensure that the threads are joined.
+      /// A move aware vector type
+      //typedef scoped_thread<> thread_t;
+      typedef thread thread_t;
+      typedef csbl::vector<thread_t> thread_vector;
 
-  public:
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      try
-      {
-        work task;
-        if (work_queue.try_pull(task) == queue_op_status::success)
-        {
-          task();
-          return true;
-        }
-        return false;
-      }
-      catch (...)
-      {
-        std::terminate();
-        //return false;
-      }
-    }
-    /**
-     * Effects: schedule one task or yields
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    void schedule_one_or_yield()
-    {
-        if ( ! try_executing_one())
-        {
-          this_thread::yield();
-        }
-    }
-  private:
+      /// the thread safe work queue
+      concurrent::sync_queue<work > work_queue;
+      /// A move aware vector
+      thread_vector threads;
+      unsigned const thread_count;
+      boost::function<void(basic_thread_pool)> at_thread_entry;
+      friend class basic_thread_pool;
 
-    /**
-     * The main loop of the worker threads
-     */
-    void worker_thread()
-    {
-      try
+
+    public:
+      /**
+       * Effects: try to execute one task.
+       * Returns: whether a task has been executed.
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      bool try_executing_one()
       {
-        for(;;)
+        try
         {
           work task;
-          queue_op_status st = work_queue.wait_pull(task);
-          if (st == queue_op_status::closed) {
-            return;
+          if (work_queue.try_pull(task) == queue_op_status::success)
+          {
+            task();
+            return true;
           }
-          task();
+          return false;
+        }
+        catch (...)
+        {
+          std::terminate();
+          return false;
         }
       }
-      catch (...)
+      /**
+       * Effects: schedule one task or yields
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      void schedule_one_or_yield()
       {
-        std::terminate();
-        return;
+          if ( ! try_executing_one())
+          {
+            this_thread::yield();
+          }
       }
-    }
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <class AtThreadEntry>
-    void worker_thread1(AtThreadEntry& at_thread_entry)
-    {
-      at_thread_entry(*this);
-      worker_thread();
-    }
-#endif
-    void worker_thread2(void(*at_thread_entry)(basic_thread_pool&))
-    {
-      at_thread_entry(*this);
-      worker_thread();
-    }
-    template <class AtThreadEntry>
-    void worker_thread3(BOOST_THREAD_FWD_REF(AtThreadEntry) at_thread_entry)
-    {
-      at_thread_entry(*this);
-      worker_thread();
-    }
-    static void do_nothing_at_thread_entry(basic_thread_pool&) {}
+    private:
 
+      /**
+       * The main loop of the worker threads
+       */
+      void worker_thread()
+      {
+        // fixme: this call results on segmentation fault
+        //at_thread_entry(basic_thread_pool(this->shared_from_this()));
+        try
+        {
+          for(;;)
+          {
+            work task;
+            queue_op_status st = work_queue.wait_pull(task);
+            if (st == queue_op_status::closed) break;
+            task();
+          }
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+
+      static void do_nothing_at_thread_entry(basic_thread_pool) {}
+
+      void init()
+      {
+        try
+        {
+          threads.reserve(thread_count);
+          for (unsigned i = 0; i < thread_count; ++i)
+          {
+            thread th (&shared_state::worker_thread, this);
+            threads.push_back(thread_t(boost::move(th)));
+          }
+        }
+        catch (...)
+        {
+          close();
+          throw;
+        }
+      }
+
+    public:
+      /// basic_thread_pool is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a thread pool that runs closures on \c thread_count threads.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+      shared_state(unsigned const thread_count = thread::hardware_concurrency()+1)
+      : thread_count(thread_count),
+        at_thread_entry(do_nothing_at_thread_entry)
+      {
+      }
+      /**
+       * \b Effects: creates a thread pool that runs closures on \c thread_count threads
+       * and executes the at_thread_entry function at the entry of each created thread. .
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <class AtThreadEntry>
+      shared_state( unsigned const thread_count, AtThreadEntry& at_thread_entry)
+      : thread_count(thread_count),
+        at_thread_entry(at_thread_entry)
+      {
+      }
+  #endif
+      shared_state( unsigned const thread_count, void(*at_thread_entry)(basic_thread_pool))
+      : thread_count(thread_count),
+        at_thread_entry(at_thread_entry)
+      {
+      }
+      template <class AtThreadEntry>
+      shared_state( unsigned const thread_count, BOOST_THREAD_FWD_REF(AtThreadEntry) at_thread_entry)
+      : thread_count(thread_count),
+        at_thread_entry(boost::move(at_thread_entry))
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c basic_thread_pool destructor.
+       */
+      ~shared_state()
+      {
+        // signal to all the worker threads that there will be no more submissions.
+        close();
+        join();
+        // joins all the threads as the threads were scoped_threads
+      }
+
+      /**
+       * \b Effects: join all the threads.
+       */
+      void join()
+      {
+        for (unsigned i = 0; i < threads.size(); ++i)
+        {
+          if (this_thread::get_id() == threads[i].get_id()) continue;
+          threads[i].join();
+        }
+      }
+
+      /**
+       * \b Effects: close the \c basic_thread_pool for submissions.
+       * The worker threads will work until there is no more closures to run.
+       */
+      void close()
+      {
+        work_queue.close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return work_queue.closed();
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c basic_thread_pool will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        work_queue.push(work(closure));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        work_queue.push(work(closure));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_RV_REF(Closure) closure)
+      {
+        work_queue.push(work(boost::forward<Closure>(closure)));
+      }
+
+      /**
+       * \b Requires: This must be called from an scheduled task.
+       *
+       * \b Effects: reschedule functions until pred()
+       */
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred)
+      {
+        do {
+          if ( ! try_executing_one())
+          {
+            return false;
+          }
+        } while (! pred());
+        return true;
+      }
+    };
+
+    /**
+     * \b Effects: creates a thread pool with this shared state.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     */
+    friend struct shared_state;
+    basic_thread_pool(shared_ptr<shared_state> ptr)
+    : pimpl(ptr)
+    {
+    }
   public:
-    /// basic_thread_pool is not copyable.
-    BOOST_THREAD_NO_COPYABLE(basic_thread_pool)
-
     /**
      * \b Effects: creates a thread pool that runs closures on \c thread_count threads.
      *
      * \b Throws: Whatever exception is thrown while initializing the needed resources.
      */
     basic_thread_pool(unsigned const thread_count = thread::hardware_concurrency()+1)
+    : pimpl(make_shared<shared_state>(thread_count))
     {
-      try
-      {
-        threads.reserve(thread_count);
-        for (unsigned i = 0; i < thread_count; ++i)
-        {
-#if 1
-          thread th (&basic_thread_pool::worker_thread, this);
-          threads.push_back(thread_t(boost::move(th)));
-#else
-          threads.push_back(thread_t(&basic_thread_pool::worker_thread, this)); // do not compile
-#endif
-        }
-      }
-      catch (...)
-      {
-        close();
-        throw;
-      }
+      pimpl->init();
     }
+
     /**
      * \b Effects: creates a thread pool that runs closures on \c thread_count threads
      * and executes the at_thread_entry function at the entry of each created thread. .
@@ -159,61 +294,24 @@ namespace executors
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <class AtThreadEntry>
     basic_thread_pool( unsigned const thread_count, AtThreadEntry& at_thread_entry)
+    : pimpl(make_shared<shared_state>(thread_count, at_thread_entry))
     {
-      try
-      {
-        threads.reserve(thread_count);
-        for (unsigned i = 0; i < thread_count; ++i)
-        {
-          thread th (&basic_thread_pool::worker_thread1<AtThreadEntry>, this, at_thread_entry);
-          threads.push_back(thread_t(boost::move(th)));
-          //threads.push_back(thread_t(&basic_thread_pool::worker_thread, this)); // do not compile
-        }
-      }
-      catch (...)
-      {
-        close();
-        throw;
-      }
+      pimpl->init();
     }
 #endif
-    basic_thread_pool( unsigned const thread_count, void(*at_thread_entry)(basic_thread_pool&))
+
+    basic_thread_pool( unsigned const thread_count, void(*at_thread_entry)(basic_thread_pool))
+    : pimpl(make_shared<shared_state>(thread_count, at_thread_entry))
     {
-      try
-      {
-        threads.reserve(thread_count);
-        for (unsigned i = 0; i < thread_count; ++i)
-        {
-          thread th (&basic_thread_pool::worker_thread2, this, at_thread_entry);
-          threads.push_back(thread_t(boost::move(th)));
-          //threads.push_back(thread_t(&basic_thread_pool::worker_thread, this)); // do not compile
-        }
-      }
-      catch (...)
-      {
-        close();
-        throw;
-      }
+      pimpl->init();
     }
     template <class AtThreadEntry>
     basic_thread_pool( unsigned const thread_count, BOOST_THREAD_FWD_REF(AtThreadEntry) at_thread_entry)
+    : pimpl(make_shared<shared_state>(thread_count, boost::forward<AtThreadEntry>(at_thread_entry)))
     {
-      try
-      {
-        threads.reserve(thread_count);
-        for (unsigned i = 0; i < thread_count; ++i)
-        {
-          thread th (&basic_thread_pool::worker_thread3<AtThreadEntry>, this, boost::forward<AtThreadEntry>(at_thread_entry));
-          threads.push_back(thread_t(boost::move(th)));
-          //threads.push_back(thread_t(&basic_thread_pool::worker_thread, this)); // do not compile
-        }
-      }
-      catch (...)
-      {
-        close();
-        throw;
-      }
+      pimpl->init();
     }
+
     /**
      * \b Effects: Destroys the thread pool.
      *
@@ -221,10 +319,16 @@ namespace executors
      */
     ~basic_thread_pool()
     {
-      // signal to all the worker threads that there will be no more submissions.
-      close();
-      // joins all the threads before destroying the thread pool resources (e.g. the queue).
-      join();
+    }
+
+    /**
+     * Effects: try to execute one task.
+     * Returns: whether a task has been executed.
+     * Throws: whatever the current task constructor throws or the task() throws.
+     */
+    bool try_executing_one()
+    {
+      return pimpl->try_executing_one();
     }
 
     /**
@@ -232,10 +336,7 @@ namespace executors
      */
     void join()
     {
-      for (unsigned i = 0; i < threads.size(); ++i)
-      {
-        threads[i].join();
-      }
+      pimpl->join();
     }
 
     /**
@@ -244,7 +345,7 @@ namespace executors
      */
     void close()
     {
-      work_queue.close();
+      pimpl->close();
     }
 
     /**
@@ -252,7 +353,7 @@ namespace executors
      */
     bool closed()
     {
-      return work_queue.closed();
+      return pimpl->closed();
     }
 
     /**
@@ -266,28 +367,23 @@ namespace executors
      * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
      * Whatever exception that can be throw while storing the closure.
      */
-    void submit(BOOST_THREAD_RV_REF(work) closure)  {
-      work_queue.push(boost::move(closure));
-    }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <typename Closure>
     void submit(Closure & closure)
     {
-      submit(work(closure));
+      pimpl->submit(closure);
     }
 #endif
     void submit(void (*closure)())
     {
-      submit(work(closure));
+      pimpl->submit(closure);
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      //submit(work(boost::forward<Closure>(closure)));
-      work w((boost::forward<Closure>(closure)));
-      submit(boost::move(w));
+      pimpl->submit(boost::forward<Closure>(closure));
     }
 
     /**
@@ -298,15 +394,16 @@ namespace executors
     template <typename Pred>
     bool reschedule_until(Pred const& pred)
     {
-      do {
-        if ( ! try_executing_one())
-        {
-          return false;
-        }
-      } while (! pred());
-      return true;
+      return pimpl->reschedule_until(pred);
     }
 
+    void schedule_one_or_yield()
+    {
+      return pimpl->schedule_one_or_yield();
+    }
+
+  private:
+    shared_ptr<shared_state> pimpl;
   };
 }
 using executors::basic_thread_pool;

include/boost/thread/executors/detail/priority_executor_base.hpp

@@ -24,7 +24,6 @@ namespace detail
   class priority_executor_base
   {
   public:
-    //typedef boost::function<void()> work;
     typedef executors::work_pq work;
   protected:
     typedef Queue queue_type;

include/boost/thread/executors/executor.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2013,2014 Vicente J. Botet Escriba
+// Copyright (C) 2013,2015 Vicente J. Botet Escriba
 //
 //  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)
@@ -27,8 +27,6 @@ namespace boost
     /// type-erasure to store the works to do
     typedef  executors::work work;
 
-    /// executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(executor)
     executor() {}
 
     /**
@@ -99,10 +97,9 @@ namespace boost
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      //submit(work(boost::forward<Closure>(closure)));
-      work w((boost::forward<Closure>(closure)));
+      work w = boost::move(closure);
       submit(boost::move(w));
     }
 
@@ -129,7 +126,6 @@ namespace boost
     bool reschedule_until(Pred const& pred)
     {
       do {
-        //schedule_one_or_yield();
         if ( ! try_executing_one())
         {
           return false;

include/boost/thread/executors/executor_adaptor.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2013,2014 Vicente J. Botet Escriba
+// Copyright (C) 2013,2015 Vicente J. Botet Escriba
 //
 //  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)
@@ -30,9 +30,8 @@ namespace executors
     /// type-erasure to store the works to do
     typedef  executor::work work;
 
-    /// executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(executor_adaptor)
-
+//    executor_adaptor(executor_adaptor const&) = default;
+//    executor_adaptor(executor_adaptor &&) = default;
     /**
      * executor_adaptor constructor
      */
@@ -98,6 +97,9 @@ namespace executors
     void submit(BOOST_THREAD_RV_REF(work) closure)  {
       return ex.submit(boost::move(closure));
     }
+//    void submit(work & closure)  {
+//      return ex.submit(closure);
+//    }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <typename Closure>
@@ -112,11 +114,9 @@ namespace executors
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      //submit(work(boost::forward<Closure>(closure)));
-      work w((boost::forward<Closure>(closure)));
-      submit(boost::move(w));
+      submit(work(boost::forward<Closure>(closure)));
     }
 
     /**

include/boost/thread/executors/generic_executor.hpp

@@ -0,0 +1,150 @@
+// Copyright (C) 2015 Vicente J. Botet Escriba
+//
+//  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_EXECUTORS_GENERIC_EXECUTOR_HPP
+#define BOOST_THREAD_EXECUTORS_GENERIC_EXECUTOR_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/executors/executor_adaptor.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/type_traits/decay.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+  namespace executors
+  {
+
+  class generic_executor
+  {
+    shared_ptr<executor> ex;
+  public:
+    /// type-erasure to store the works to do
+    typedef executors::work work;
+
+    //generic_executor(generic_executor const&) = default;
+    //generic_executor(generic_executor &&) = default;
+
+    template<typename Executor>
+    generic_executor(Executor const& ex
+        , typename boost::disable_if<is_same<Executor, generic_executor>,
+          int* >::type =  (int*)0
+    )
+    //: ex(make_shared<executor_adaptor<Executor> >(ex)) // todo check why this doesn't work with C++03
+    : ex( new executor_adaptor<Executor>(ex) )
+    {
+    }
+
+    //generic_executor(generic_executor const& other) noexcept    {}
+    //generic_executor& operator=(generic_executor const& other) noexcept    {}
+
+
+    /**
+     * \par Effects
+     * Close the \c executor for submissions.
+     * The worker threads will work until there is no more closures to run.
+     */
+    void close() { ex->close(); }
+
+    /**
+     * \par Returns
+     * Whether the pool is closed for submissions.
+     */
+    bool closed() { return ex->closed(); }
+
+    void submit(BOOST_THREAD_RV_REF(work) closure)
+    {
+      ex->submit(boost::forward<work>(closure));
+    }
+
+    /**
+     * \par Requires
+     * \c Closure is a model of Callable(void()) and a model of CopyConstructible/MoveConstructible.
+     *
+     * \par Effects
+     * The specified closure will be scheduled for execution at some point in the future.
+     * If invoked closure throws an exception the thread pool will call std::terminate, as is the case with threads.
+     *
+     * \par Synchronization
+     * Completion of closure on a particular thread happens before destruction of thread's thread local variables.
+     *
+     * \par Throws
+     * \c sync_queue_is_closed if the thread pool is closed.
+     * Whatever exception that can be throw while storing the closure.
+     */
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <typename Closure>
+    void submit(Closure & closure)
+    {
+      work w ((closure));
+      submit(boost::move(w));
+    }
+#endif
+    void submit(void (*closure)())
+    {
+      work w ((closure));
+      submit(boost::move(w));
+    }
+
+    template <typename Closure>
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
+    {
+      work w = boost::move(closure);
+      submit(boost::move(w));
+    }
+
+//    size_t num_pending_closures() const
+//    {
+//      return ex->num_pending_closures();
+//    }
+
+    /**
+     * \par Effects
+     * Try to execute one task.
+     *
+     * \par Returns
+     * Whether a task has been executed.
+     *
+     * \par Throws
+     * Whatever the current task constructor throws or the task() throws.
+     */
+    bool try_executing_one() { return ex->try_executing_one(); }
+
+    /**
+     * \par Requires
+     * This must be called from an scheduled task.
+     *
+     * \par Effects
+     * reschedule functions until pred()
+     */
+    template <typename Pred>
+    bool reschedule_until(Pred const& pred)
+    {
+      do {
+        //schedule_one_or_yield();
+        if ( ! try_executing_one())
+        {
+          return false;
+        }
+      } while (! pred());
+      return true;
+    }
+
+  };
+  }
+  using executors::generic_executor;
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/executors/generic_executor_ref.hpp

@@ -13,7 +13,8 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/executors/executor.hpp>
 
-#include <boost/shared_ptr.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -99,8 +100,8 @@ namespace boost
 
     template<typename Executor>
     generic_executor_ref(Executor& ex)
-    //: ex(make_shared<executor_ref<Executor> >(ex)) // todo check why this doesn't works with C++03
-    : ex( new executor_ref<Executor>(ex) )
+    //: ex(make_shared<executor_ref<typename decay<Executor>::type> >(ex)) // todo check why this doesn't work with C++03
+    : ex( new executor_ref<typename decay<Executor>::type>(ex) )
     {
     }
 
@@ -121,6 +122,11 @@ namespace boost
      */
     bool closed() { return ex->closed(); }
 
+    void submit(BOOST_THREAD_RV_REF(work) closure)
+    {
+      ex->submit(boost::forward<work>(closure));
+    }
+
     /**
      * \par Requires
      * \c Closure is a model of Callable(void()) and a model of CopyConstructible/MoveConstructible.
@@ -137,31 +143,24 @@ namespace boost
      * Whatever exception that can be throw while storing the closure.
      */
 
-    void submit(BOOST_THREAD_RV_REF(work) closure)
-    {
-      ex->submit(boost::move(closure));
-    }
-
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <typename Closure>
     void submit(Closure & closure)
     {
-      //work w ((closure));
-      //submit(boost::move(w));
-      submit(work(closure));
+      work w ((closure));
+      submit(boost::move(w));
     }
 #endif
     void submit(void (*closure)())
     {
       work w ((closure));
       submit(boost::move(w));
-      //submit(work(closure));
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      work w((boost::forward<Closure>(closure)));
+      work w = boost::move(closure);
       submit(boost::move(w));
     }
 

include/boost/thread/executors/generic_serial_executor.hpp

@@ -0,0 +1,284 @@
+// Copyright (C) 2013,2015 Vicente J. Botet Escriba
+//
+//  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)
+//
+// 2013/11 Vicente J. Botet Escriba
+//    first implementation of a simple serial scheduler.
+
+#ifndef BOOST_THREAD_GENERIC_SERIAL_EXECUTOR_HPP
+#define BOOST_THREAD_GENERIC_SERIAL_EXECUTOR_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/concurrent_queues/sync_queue.hpp>
+#include <boost/thread/executors/work.hpp>
+#include <boost/thread/executors/generic_executor.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/thread/scoped_thread.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/decay.hpp>
+
+#include <boost/thread/caller_context.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+namespace executors
+{
+  class generic_serial_executor
+  {
+  public:
+    /// type-erasure to store the works to do
+    typedef  executors::work work;
+  private:
+
+    struct shared_state {
+      typedef  executors::work work;
+      typedef  scoped_thread<> thread_t;
+
+      /// the thread safe work queue
+      concurrent::sync_queue<work > work_queue;
+      generic_executor ex;
+      thread_t thr;
+
+      struct try_executing_one_task {
+        work& task;
+        boost::promise<void> &p;
+        try_executing_one_task(work& task, boost::promise<void> &p)
+        : task(task), p(p) {}
+        void operator()() {
+          try {
+            task();
+            p.set_value();
+          } catch (...)
+          {
+            p.set_exception(current_exception());
+          }
+        }
+      };
+    public:
+      /**
+       * \par Returns
+       * The underlying executor wrapped on a generic executor reference.
+       */
+      generic_executor& underlying_executor() BOOST_NOEXCEPT { return ex; }
+
+    private:
+
+      /**
+       * The main loop of the worker thread
+       */
+      void worker_thread()
+      {
+        try
+        {
+          for(;;)
+          {
+            work task;
+            queue_op_status st = work_queue.wait_pull(task);
+            if (st == queue_op_status::closed) return;
+
+            boost::promise<void> p;
+            try_executing_one_task tmp(task,p);
+            ex.submit(tmp);
+            p.get_future().wait();
+          }
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+
+    public:
+      /// shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+      template <class Executor>
+      shared_state(Executor const& ex)
+      : ex(ex), thr(&shared_state::worker_thread, this)
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c shared_state destructor.
+       */
+      ~shared_state()
+      {
+        // signal to the worker thread that there will be no more submissions.
+        close();
+      }
+
+      /**
+       * \b Effects: close the \c generic_serial_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        work_queue.close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return work_queue.closed();
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c generic_serial_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        work_queue.push(work(closure));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        work_queue.push(work(closure));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_RV_REF(Closure) closure)
+      {
+        work_queue.push(work(boost::forward<Closure>(closure)));
+      }
+
+    };
+
+  public:
+
+//    generic_serial_executor(generic_serial_executor const&) = default;
+//    generic_serial_executor(generic_serial_executor &&) = default;
+
+    /**
+     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     */
+    template <class Executor>
+    generic_serial_executor(Executor const& ex
+        , typename boost::disable_if<is_same<Executor, generic_serial_executor>,
+          int* >::type =  (int*)0)
+    : pimpl(make_shared<shared_state>(ex))
+    {
+    }
+    /**
+     * \b Effects: Destroys the thread pool.
+     *
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c generic_serial_executor destructor.
+     */
+    ~generic_serial_executor()
+    {
+    }
+
+    /**
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
+     */
+    generic_executor& underlying_executor() BOOST_NOEXCEPT
+    {
+      return pimpl->underlying_executor();
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    bool try_executing_one()
+    {
+      return false;
+    }
+
+    /**
+     * \b Effects: close the \c generic_serial_executor for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      pimpl->close();
+    }
+
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      return pimpl->closed();
+    }
+
+    /**
+     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+     *
+     * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+     * If invoked closure throws an exception the \c generic_serial_executor will call \c std::terminate, as is the case with threads.
+     *
+     * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+     *
+     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+     * Whatever exception that can be throw while storing the closure.
+     */
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <typename Closure>
+    void submit(Closure & closure)
+    {
+      pimpl->submit(closure);
+    }
+#endif
+    void submit(void (*closure)())
+    {
+      pimpl->submit(closure);
+    }
+
+    template <typename Closure>
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
+    {
+      pimpl->submit(boost::forward<Closure>(closure));
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    template <typename Pred>
+    bool reschedule_until(Pred const& pred)
+    {
+      return false;
+    }
+  private:
+    shared_ptr<shared_state> pimpl;
+  };
+}
+using executors::generic_serial_executor;
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/executors/generic_serial_executor_cont.hpp

@@ -0,0 +1,265 @@
+// Copyright (C) 2015 Vicente J. Botet Escriba
+//
+//  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)
+//
+// 2013/11 Vicente J. Botet Escriba
+//    first implementation of a simple serial scheduler.
+
+#ifndef BOOST_THREAD_GENERIC_SERIAL_EXECUTOR_CONT_HPP
+#define BOOST_THREAD_GENERIC_SERIAL_EXECUTOR_CONT_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/executors/work.hpp>
+#include <boost/thread/executors/generic_executor.hpp>
+#include <boost/thread/future.hpp>
+#include <boost/thread/scoped_thread.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/decay.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+namespace executors
+{
+  class generic_serial_executor_cont
+  {
+  public:
+    /// type-erasure to store the works to do
+    typedef  executors::work work;
+  private:
+
+    struct shared_state {
+      typedef  executors::work work;
+
+    generic_executor ex_;
+    future<void> fut_; // protected by mtx_
+    bool closed_; // protected by mtx_
+    mutex mtx_;
+
+    struct continuation {
+      work task;
+      template <class X>
+      struct result {
+        typedef void type;
+      };
+      continuation(BOOST_THREAD_RV_REF(work) tsk)
+      : task(boost::move(tsk)) {}
+      void operator()(future<void> f)
+      {
+        try {
+          task();
+        } catch (...)  {
+          std::terminate();
+        }
+      }
+    };
+
+    bool closed(lock_guard<mutex>&) const
+    {
+      return closed_;
+    }
+  public:
+    /**
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
+     */
+    generic_executor& underlying_executor() BOOST_NOEXCEPT { return ex_; }
+
+    /// shared_state is not copyable.
+    BOOST_THREAD_NO_COPYABLE(shared_state)
+
+    /**
+     * \b Effects: creates a serial executor that runs closures in fifo order using one the associated executor.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     *
+     * \b Notes:
+     * * The lifetime of the associated executor must outlive the serial executor.
+     * * The current implementation doesn't support submission from synchronous continuation, that is,
+     *     - the executor must execute the continuation asynchronously or
+     *     - the continuation can not submit to this serial executor.
+     */
+    template <class Executor>
+    shared_state(Executor const& ex)
+    : ex_(ex), fut_(make_ready_future()), closed_(false)
+    {
+    }
+    /**
+     * \b Effects: Destroys the thread pool.
+     *
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c generic_serial_executor_cont destructor.
+     */
+    ~shared_state()
+    {
+      // signal to the worker thread that there will be no more submissions.
+      close();
+    }
+
+    /**
+     * \b Effects: close the \c generic_serial_executor_cont for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      lock_guard<mutex> lk(mtx_);
+      closed_ = true;;
+    }
+
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      lock_guard<mutex> lk(mtx_);
+      return closed(lk);
+    }
+
+    /**
+     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+     *
+     * \b Effects: The specified \c closure will be scheduled for execution after the last submitted closure finish.
+     * If the invoked closure throws an exception the \c generic_serial_executor_cont will call \c std::terminate, as is the case with threads.
+     *
+     * \b Throws: \c sync_queue_is_closed if the executor is closed.
+     * Whatever exception that can be throw while storing the closure.
+     *
+     */
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <typename Closure>
+    void submit(Closure & closure)
+    {
+      lock_guard<mutex> lk(mtx_);
+      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+      fut_ = fut_.then(ex_, continuation(work(closure)));
+    }
+#endif
+    void submit(void (*closure)())
+    {
+      lock_guard<mutex> lk(mtx_);
+      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+      fut_ = fut_.then(ex_, continuation(work(closure)));
+    }
+
+    template <typename Closure>
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
+    {
+      lock_guard<mutex> lk(mtx_);
+      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+      fut_ = fut_.then(ex_, continuation(work(boost::forward<Closure>(closure))));
+    }
+    };
+  public:
+    /**
+     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     */
+    template <class Executor>
+    generic_serial_executor_cont(Executor const& ex
+                , typename boost::disable_if<is_same<Executor, generic_serial_executor_cont>,
+                  int* >::type =  (int*)0)
+    : pimpl(make_shared<shared_state>(ex))
+    {
+    }
+    /**
+     * \b Effects: Destroys the thread pool.
+     *
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor destructor.
+     */
+    ~generic_serial_executor_cont()
+    {
+    }
+
+    /**
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
+     */
+    generic_executor& underlying_executor() BOOST_NOEXCEPT
+    {
+      return pimpl->underlying_executor();
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    bool try_executing_one()
+    {
+      return false;
+    }
+
+    /**
+     * \b Effects: close the \c serial_executor for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      pimpl->close();
+    }
+
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      return pimpl->closed();
+    }
+
+    /**
+     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+     *
+     * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+     * If invoked closure throws an exception the \c serial_executor will call \c std::terminate, as is the case with threads.
+     *
+     * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+     *
+     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+     * Whatever exception that can be throw while storing the closure.
+     */
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <typename Closure>
+    void submit(Closure & closure)
+    {
+      pimpl->submit(closure);
+    }
+#endif
+    void submit(void (*closure)())
+    {
+      pimpl->submit(closure);
+    }
+
+    template <typename Closure>
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
+    {
+      pimpl->submit(boost::forward<Closure>(closure));
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    template <typename Pred>
+    bool reschedule_until(Pred const& pred)
+    {
+      return false;
+    }
+  private:
+    shared_ptr<shared_state> pimpl;
+  };
+}
+using executors::generic_serial_executor_cont;
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/executors/inline_executor.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-2015 Vicente J. Botet Escriba
 //
 //  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)
@@ -14,6 +14,9 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/executors/work.hpp>
 
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
@@ -25,142 +28,227 @@ namespace executors
   public:
     /// type-erasure to store the works to do
     typedef  executors::work work;
-    bool closed_;
-    mutable mutex mtx_;
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      return false;
-    }
+  private:
 
+    struct shared_state {
+      typedef  executors::work work;
+
+      bool closed_;
+      mutable mutex mtx_;
+
+      /**
+       * Effects: try to execute one task.
+       * Returns: whether a task has been executed.
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      bool try_executing_one()
+      {
+        return false;
+      }
+
+      /// shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a inline executor that runs closures immediately.
+       *
+       * \b Throws: Nothing.
+       */
+      shared_state()
+      : closed_(false)
+      {
+      }
+      /**
+       * \b Effects: Destroys the inline executor.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c inline_executor destructor.
+       */
+      ~shared_state()
+      {
+        // signal to all the worker thread that there will be no more submissions.
+        close();
+      }
+
+      /**
+       * \b Effects: close the \c inline_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        lock_guard<mutex> lk(mtx_);
+        closed_ = true;
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed(lock_guard<mutex>& )  const
+      {
+        return closed_;
+      }
+      bool closed() const
+      {
+        lock_guard<mutex> lk(mtx_);
+        return closed(lk);
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c inline_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        {
+          lock_guard<mutex> lk(mtx_);
+          if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        }
+        try
+        {
+          closure();
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        {
+          lock_guard<mutex> lk(mtx_);
+          if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        }
+        try
+        {
+          closure();
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+      {
+        {
+          lock_guard<mutex> lk(mtx_);
+          if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        }
+        try
+        {
+          closure();
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
+        }
+      }
+
+      /**
+       * \b Requires: This must be called from an scheduled task.
+       *
+       * \b Effects: reschedule functions until pred()
+       */
+      template <typename Pred>
+      bool reschedule_until(Pred const& )
+      {
+        return false;
+      }
+  };
   public:
-    /// inline_executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(inline_executor)
+  /**
+   * \b Effects: creates a inline executor that runs closures immediately.
+   *
+   * \b Throws: Nothing.
+   */
+  inline_executor()
+  : pimpl(make_shared<shared_state>())
+  {
+  }
 
-    /**
-     * \b Effects: creates a inline executor that runs closures immediately.
-     *
-     * \b Throws: Nothing.
-     */
-    inline_executor()
-    : closed_(false)
-    {
-    }
-    /**
-     * \b Effects: Destroys the inline executor.
-     *
-     * \b Synchronization: The completion of all the closures happen before the completion of the \c inline_executor destructor.
-     */
-    ~inline_executor()
-    {
-      // signal to all the worker thread that there will be no more submissions.
-      close();
-    }
+  /**
+   * \b Effects: close the \c inline_executor for submissions.
+   * The loop will work until there is no more closures to run.
+   */
+  void close()
+  {
+    pimpl->close();
+  }
 
-    /**
-     * \b Effects: close the \c inline_executor for submissions.
-     * The loop will work until there is no more closures to run.
-     */
-    void close()
-    {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;
-    }
+  /**
+   * \b Returns: whether the executor is closed for submissions.
+   */
+  bool closed() const
+  {
+    return pimpl->closed();
+  }
 
-    /**
-     * \b Returns: whether the pool is closed for submissions.
-     */
-    bool closed(lock_guard<mutex>& )
-    {
-      return closed_;
-    }
-    bool closed()
-    {
-      lock_guard<mutex> lk(mtx_);
-      return closed(lk);
-    }
-
-    /**
-     * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
-     *
-     * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
-     * If invoked closure throws an exception the \c inline_executor will call \c std::terminate, as is the case with threads.
-     *
-     * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
-     *
-     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
-     * Whatever exception that can be throw while storing the closure.
-     */
+  /**
+   * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+   *
+   * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+   * If invoked closure throws an exception the \c inline_executor will call \c std::terminate, as is the case with threads.
+   *
+   * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+   *
+   * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+   * Whatever exception that can be throw while storing the closure.
+   */
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <typename Closure>
-    void submit(Closure & closure)
-    {
-      {
-        lock_guard<mutex> lk(mtx_);
-        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      }
-      try
-      {
-        closure();
-      }
-      catch (...)
-      {
-        std::terminate();
-        return;
-      }
-    }
+  template <typename Closure>
+  void submit(Closure & closure)
+  {
+    pimpl->submit(closure);
+  }
 #endif
-    void submit(void (*closure)())
-    {
-      {
-        lock_guard<mutex> lk(mtx_);
-        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      }
-      try
-      {
-        closure();
-      }
-      catch (...)
-      {
-        std::terminate();
-        return;
-      }
-    }
+  void submit(void (*closure)())
+  {
+    pimpl->submit(closure);
+  }
 
-    template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
-    {
-      {
-        lock_guard<mutex> lk(mtx_);
-        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      }
-      try
-      {
-        closure();
-      }
-      catch (...)
-      {
-        std::terminate();
-        return;
-      }
-    }
+  template <typename Closure>
+  void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+  {
+    pimpl->submit(boost::forward<Closure>(closure));
+  }
 
-    /**
-     * \b Requires: This must be called from an scheduled task.
-     *
-     * \b Effects: reschedule functions until pred()
-     */
-    template <typename Pred>
-    bool reschedule_until(Pred const& )
-    {
-      return false;
-    }
+  /**
+   * Effects: try to execute one task.
+   * Returns: whether a task has been executed.
+   * Throws: whatever the current task constructor throws or the task() throws.
+   */
+  bool try_executing_one()
+  {
+    return pimpl->try_executing_one();
+  }
 
+  /**
+   * \b Requires: This must be called from an scheduled task.
+   *
+   * \b Effects: reschedule functions until pred()
+   */
+  template <typename Pred>
+  bool reschedule_until(Pred const& p)
+  {
+    return pimpl->reschedule_until(p);
+  }
+  private:
+    shared_ptr<shared_state> pimpl;
   };
 }
 using executors::inline_executor;

include/boost/thread/executors/loop_executor.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2013,2014 Vicente J. Botet Escriba
+// Copyright (C) 2013-2015 Vicente J. Botet Escriba
 //
 //  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)
@@ -17,6 +17,9 @@
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
 #include <boost/thread/executors/work.hpp>
 
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
@@ -30,59 +33,170 @@ namespace executors
     /// type-erasure to store the works to do
     typedef  executors::work work;
   private:
-    /// the thread safe work queue
-    concurrent::sync_queue<work > work_queue;
 
-  public:
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      work task;
-      try
+    struct shared_state {
+      typedef  executors::work work;
+      /// the thread safe work queue
+      concurrent::sync_queue<work > work_queue;
+
+      /**
+       * Effects: try to execute one task.
+       * Returns: whether a task has been executed.
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      bool try_executing_one()
       {
-        if (work_queue.try_pull(task) == queue_op_status::success)
+        work task;
+        try
         {
+          if (work_queue.try_pull(task) == queue_op_status::success)
+          {
+            task();
+            return true;
+          }
+          return false;
+        }
+        catch (...)
+        {
+          std::terminate();
+          return false;
+        }
+      }
+      /**
+       * Effects: schedule one task or yields
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      void schedule_one_or_yield()
+      {
+          if ( ! try_executing_one())
+          {
+            this_thread::yield();
+          }
+      }
+
+      /// loop_executor is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+      shared_state()
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c loop_executor destructor.
+       */
+      ~shared_state()
+      {
+        // signal to all the worker thread that there will be no more submissions.
+        close();
+      }
+
+      /**
+       * The main loop of the worker thread
+       */
+      void loop()
+      {
+        while (!closed())
+        {
+          schedule_one_or_yield();
+        }
+        while (try_executing_one())
+        {
+        }
+      }
+
+      /**
+       * \b Effects: close the \c loop_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        work_queue.close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return work_queue.closed();
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c loop_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        work_queue.push(work(closure));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        work_queue.push(work(closure));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_RV_REF(Closure) closure)
+      {
+        work_queue.push(work(boost::forward<Closure>(closure)));
+      }
+
+      /**
+       * \b Requires: This must be called from an scheduled task.
+       *
+       * \b Effects: reschedule functions until pred()
+       */
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred)
+      {
+        do {
+          if ( ! try_executing_one())
+          {
+            return false;
+          }
+        } while (! pred());
+        return true;
+      }
+
+      /**
+       * run queued closures
+       */
+      void run_queued_closures()
+      {
+        sync_queue<work>::underlying_queue_type q = work_queue.underlying_queue();
+        while (! q.empty())
+        {
+          work& task = q.front();
           task();
-          return true;
+          q.pop_front();
         }
-        return false;
       }
-      catch (...)
-      {
-        std::terminate();
-        //return false;
-      }
-    }
-  private:
-    /**
-     * Effects: schedule one task or yields
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    void schedule_one_or_yield()
-    {
-        if ( ! try_executing_one())
-        {
-          this_thread::yield();
-        }
-    }
-
-
-
 
+    };
   public:
-    /// loop_executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(loop_executor)
-
     /**
      * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
      *
      * \b Throws: Whatever exception is thrown while initializing the needed resources.
      */
     loop_executor()
+    : pimpl(make_shared<shared_state>())
     {
     }
     /**
@@ -92,22 +206,33 @@ namespace executors
      */
     ~loop_executor()
     {
-      // signal to all the worker thread that there will be no more submissions.
-      close();
     }
 
+    /**
+     * Effects: try to execute one task.
+     * Returns: whether a task has been executed.
+     * Throws: whatever the current task constructor throws or the task() throws.
+     */
+    bool try_executing_one()
+    {
+      return pimpl->try_executing_one();
+    }
+//    /**
+//     * Effects: schedule one task or yields
+//     * Throws: whatever the current task constructor throws or the task() throws.
+//     */
+//    void schedule_one_or_yield()
+//    {
+//      return pimpl->schedule_one_or_yield();
+//    }
+
+
     /**
      * The main loop of the worker thread
      */
     void loop()
     {
-      while (!closed())
-      {
-        schedule_one_or_yield();
-      }
-      while (try_executing_one())
-      {
-      }
+      pimpl->loop();
     }
 
     /**
@@ -116,7 +241,7 @@ namespace executors
      */
     void close()
     {
-      work_queue.close();
+      pimpl->close();
     }
 
     /**
@@ -124,7 +249,7 @@ namespace executors
      */
     bool closed()
     {
-      return work_queue.closed();
+      return pimpl->closed();
     }
 
     /**
@@ -138,29 +263,23 @@ namespace executors
      * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
      * Whatever exception that can be throw while storing the closure.
      */
-    void submit(BOOST_THREAD_RV_REF(work) closure)  {
-      work_queue.push(boost::move(closure));
-    }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <typename Closure>
     void submit(Closure & closure)
     {
-      submit(work(closure));
-   }
+      pimpl->submit(closure);
+    }
 #endif
-
     void submit(void (*closure)())
     {
-      submit(work(closure));
+      pimpl->submit(closure);
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      //work_queue.push(work(boost::forward<Closure>(closure)));
-      work w((boost::forward<Closure>(closure)));
-      submit(boost::move(w));
+      pimpl->submit(boost::forward<Closure>(closure));
     }
 
     /**
@@ -171,13 +290,7 @@ namespace executors
     template <typename Pred>
     bool reschedule_until(Pred const& pred)
     {
-      do {
-        if ( ! try_executing_one())
-        {
-          return false;
-        }
-      } while (! pred());
-      return true;
+      return pimpl->reschedule_until(pred);
     }
 
     /**
@@ -185,15 +298,10 @@ namespace executors
      */
     void run_queued_closures()
     {
-      sync_queue<work>::underlying_queue_type q = work_queue.underlying_queue();
-      while (! q.empty())
-      {
-        work& task = q.front();
-        task();
-        q.pop_front();
-      }
+      pimpl->run_queued_closures();
     }
-
+  private:
+    shared_ptr<shared_state> pimpl;
   };
 }
 using executors::loop_executor;

include/boost/thread/executors/scheduled_thread_pool.hpp

@@ -9,36 +9,123 @@
 #define BOOST_THREAD_EXECUTORS_SCHEDULED_THREAD_POOL_HPP
 
 #include <boost/thread/executors/detail/scheduled_executor_base.hpp>
+#include <boost/thread/executors/work.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/scoped_thread.hpp>
+#include <boost/thread/csbl/vector.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 
 namespace boost
 {
 namespace executors
 {
 
-  class scheduled_thread_pool : public detail::scheduled_executor_base<>
+  template <class Clock = chrono::steady_clock>
+  class scheduled_thread_pool
   {
   private:
-    thread_group _workers;
-  public:
 
-    scheduled_thread_pool(size_t num_threads) : super()
-    {
-      for(size_t i = 0; i < num_threads; i++)
+    struct shared_state : public detail::scheduled_executor_base<> {
+
+      /// basic_thread_pool is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      typedef detail::scheduled_executor_base<> super;
+      typedef typename super::work work;
+
+      typedef scoped_thread<> thread_t;
+      typedef csbl::vector<thread_t> thread_vector;
+      thread_vector threads;
+
+      shared_state(unsigned const thread_count = thread::hardware_concurrency()+1) : super()
       {
-        _workers.create_thread(bind(&super::loop, this));
+
+        try
+        {
+          threads.reserve(thread_count);
+          for (unsigned i = 0; i < thread_count; ++i)
+          {
+  #if 1
+            thread th (&shared_state::loop, this);
+            threads.push_back(thread_t(boost::move(th)));
+  #else
+            threads.push_back(thread_t(&shared_state::loop, this)); // do not compile
+  #endif
+          }
+        }
+        catch (...)
+        {
+          close();
+          throw;
+        }
       }
+
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c basic_thread_pool destructor.
+       */
+      ~shared_state()
+      {
+        this->close();
+      }
+    }; //end class
+
+  public:
+    typedef typename shared_state::work work;
+    typedef Clock clock;
+    typedef typename clock::duration duration;
+    typedef typename clock::time_point time_point;
+
+
+    /**
+     * \b Effects: creates a thread pool that runs closures on \c thread_count threads.
+     *
+     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     */
+    scheduled_thread_pool(unsigned const thread_count = thread::hardware_concurrency()+1)
+    : pimpl(make_shared<shared_state>(thread_count))
+    {
     }
 
+    /**
+     * \b Effects: Destroys the thread pool.
+     *
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c basic_thread_pool destructor.
+     */
     ~scheduled_thread_pool()
     {
-      this->close();
-      _workers.join_all();
+    }
+    /**
+     * \b Effects: close the \c serial_executor for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      pimpl->close();
     }
 
-  private:
-    typedef detail::scheduled_executor_base<> super;
-  }; //end class
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      return pimpl->closed();
+    }
 
+    void submit_at(work w, const time_point& tp)
+    {
+      return pimpl->submit_at(boost::move(w), tp);
+    }
+
+    void submit_after(work w, const duration& d)
+    {
+      return pimpl->submit_after(boost::move(w), d);
+    }
+  private:
+    shared_ptr<shared_state> pimpl;
+  };
 } //end executors namespace
 
 using executors::scheduled_thread_pool;

include/boost/thread/executors/scheduler.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-2015 Vicente J. Botet Escriba
 //
 //  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)
@@ -13,6 +13,8 @@
 #include <boost/chrono/time_point.hpp>
 #include <boost/chrono/duration.hpp>
 #include <boost/chrono/system_clocks.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -36,7 +38,7 @@ namespace boost
       }
 
     private:
-      Executor&   ex;
+      Executor   ex;
       Function funct;
     };
 
@@ -100,8 +102,8 @@ namespace boost
       }
 
     private:
-      Scheduler&  sch;
-      Executor&   ex;
+      Scheduler   sch;
+      Executor   ex;
       typename clock::time_point  tp;
       bool  is_closed;
     };
@@ -150,8 +152,8 @@ namespace boost
       }
 
     private:
-      Scheduler& sch;
-      Executor& ex;
+      Scheduler sch;
+      Executor ex;
     }; //end class
 
     /// Wraps a reference to a @c Scheduler providing an @c Executor that
@@ -208,7 +210,7 @@ namespace boost
       }
 
     private:
-      Scheduler& sch;
+      Scheduler sch;
       time_point  tp;
       bool  is_closed;
     }; //end class
@@ -217,22 +219,71 @@ namespace boost
     /// It provides factory helper functions such as at/after that convert a @c Scheduler into an @c Executor
     /// that submit the work at/after a specific time/duration respectively.
     template <class Clock = chrono::steady_clock>
-    class scheduler : public detail::scheduled_executor_base<Clock>
+    class scheduler
     {
-    public:
-      typedef typename detail::scheduled_executor_base<Clock>::work work;
+    private:
 
+      struct shared_state : public detail::scheduled_executor_base<Clock> {
+        typedef detail::scheduled_executor_base<Clock> super;
+        typedef typename super::work work;
+        thread thr;
+
+        /// shared_state is not copyable.
+        BOOST_THREAD_NO_COPYABLE(shared_state)
+
+        shared_state()
+          : super(),
+            thr(&super::loop, this) {}
+
+        ~shared_state()
+        {
+          this->close();
+          thr.join();
+        }
+
+      };
+
+    public:
+      typedef typename shared_state::work work;
       typedef Clock clock;
+      typedef typename clock::duration duration;
+      typedef typename clock::time_point time_point;
 
       scheduler()
-        : super(),
-          thr(&super::loop, this) {}
+        : pimpl(make_shared<shared_state>())
+      {}
 
       ~scheduler()
       {
-        this->close();
-        thr.join();
       }
+
+      /**
+       * \b Effects: close the \c serial_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        pimpl->close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return pimpl->closed();
+      }
+
+      void submit_at(work w, const time_point& tp)
+      {
+        return pimpl->submit_at(boost::move(w), tp);
+      }
+
+      void submit_after(work w, const duration& d)
+      {
+        return pimpl->submit_after(boost::move(w), d);
+      }
+
       template <class Ex>
       scheduler_executor_wrapper<scheduler, Ex> on(Ex& ex)
       {
@@ -250,13 +301,10 @@ namespace boost
       {
         return at_executor<scheduler>(*this, tp);
       }
-
     private:
-      typedef detail::scheduled_executor_base<Clock> super;
-      thread thr;
+      shared_ptr<shared_state> pimpl;
     };
 
-
   }
   using executors::resubmitter;
   using executors::resubmit;

include/boost/thread/executors/scheduling_adaptor.hpp

@@ -19,7 +19,7 @@ namespace executors
   class scheduling_adpator : public detail::scheduled_executor_base<>
   {
   private:
-    Executor& _exec;
+    Executor _exec;
     thread _scheduler;
   public:
 

include/boost/thread/executors/serial_executor.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2013 Vicente J. Botet Escriba
+// Copyright (C) 2013,2015 Vicente J. Botet Escriba
 //
 //  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)
@@ -14,116 +14,168 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
 #include <boost/thread/executors/work.hpp>
-#include <boost/thread/executors/generic_executor_ref.hpp>
+#include <boost/thread/executors/generic_executor.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/thread/scoped_thread.hpp>
 
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
 {
 namespace executors
 {
+  template <class Executor>
   class serial_executor
   {
   public:
     /// type-erasure to store the works to do
     typedef  executors::work work;
   private:
-    typedef  scoped_thread<> thread_t;
 
-    /// the thread safe work queue
-    concurrent::sync_queue<work > work_queue;
-    generic_executor_ref ex;
-    thread_t thr;
+    struct shared_state {
+      typedef  executors::work work;
+      typedef  scoped_thread<> thread_t;
 
-    struct try_executing_one_task {
-      work& task;
-      boost::promise<void> &p;
-      try_executing_one_task(work& task, boost::promise<void> &p)
-      : task(task), p(p) {}
-      void operator()() {
-        try {
-          task();
-          p.set_value();
-        } catch (...)
+      /// the thread safe work queue
+      concurrent::sync_queue<work > work_queue;
+      Executor ex;
+      thread_t thr;
+
+      struct try_executing_one_task {
+        work& task;
+        boost::promise<void> &p;
+        try_executing_one_task(work& task, boost::promise<void> &p)
+        : task(task), p(p) {}
+        void operator()() {
+          try {
+            task();
+            p.set_value();
+          } catch (...)
+          {
+            p.set_exception(current_exception());
+          }
+        }
+      };
+    public:
+      /**
+       * \par Returns
+       * The underlying executor wrapped on a generic executor reference.
+       */
+      Executor& underlying_executor() BOOST_NOEXCEPT { return ex; }
+
+    private:
+
+      /**
+       * The main loop of the worker thread
+       */
+      void worker_thread()
+      {
+        try
         {
-          p.set_exception(current_exception());
+          for(;;)
+          {
+            work task;
+            queue_op_status st = work_queue.wait_pull(task);
+            if (st == queue_op_status::closed) return;
+
+            boost::promise<void> p;
+            try_executing_one_task tmp(task,p);
+            ex.submit(tmp);
+            p.get_future().wait();
+          }
+        }
+        catch (...)
+        {
+          std::terminate();
+          return;
         }
       }
+
+    public:
+      /// shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       */
+      shared_state(Executor& ex)
+      : ex(ex), thr(&shared_state::worker_thread, this)
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c shared_state destructor.
+       */
+      ~shared_state()
+      {
+        // signal to the worker thread that there will be no more submissions.
+        close();
+      }
+
+      /**
+       * \b Effects: close the \c serial_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        work_queue.close();
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        return work_queue.closed();
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c serial_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        work_queue.push(work(closure));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        work_queue.push(work(closure));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_RV_REF(Closure) closure)
+      {
+        work_queue.push(work(boost::forward<Closure>(closure)));
+      }
+
     };
-  public:
-    /**
-     * \par Returns
-     * The underlying executor wrapped on a generic executor reference.
-     */
-    generic_executor_ref& underlying_executor() BOOST_NOEXCEPT { return ex; }
-
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      work task;
-      try
-      {
-        if (work_queue.try_pull(task) == queue_op_status::success)
-        {
-          boost::promise<void> p;
-          try_executing_one_task tmp(task,p);
-          ex.submit(tmp);
-          p.get_future().wait();
-          return true;
-        }
-        return false;
-      }
-      catch (...)
-      {
-        std::terminate();
-        //return false;
-      }
-    }
-  private:
-    /**
-     * Effects: schedule one task or yields
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    void schedule_one_or_yield()
-    {
-        if ( ! try_executing_one())
-        {
-          this_thread::yield();
-        }
-    }
-
-    /**
-     * The main loop of the worker thread
-     */
-    void worker_thread()
-    {
-      while (!closed())
-      {
-        schedule_one_or_yield();
-      }
-      while (try_executing_one())
-      {
-      }
-    }
 
   public:
-    /// serial_executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(serial_executor)
 
     /**
      * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
      *
      * \b Throws: Whatever exception is thrown while initializing the needed resources.
      */
-    template <class Executor>
     serial_executor(Executor& ex)
-    : ex(ex), thr(&serial_executor::worker_thread, this)
+    : pimpl(make_shared<shared_state>(ex))
     {
     }
     /**
@@ -133,8 +185,24 @@ namespace executors
      */
     ~serial_executor()
     {
-      // signal to the worker thread that there will be no more submissions.
-      close();
+    }
+
+    /**
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
+     */
+    Executor& underlying_executor() BOOST_NOEXCEPT
+    {
+      return pimpl->underlying_executor();
+    }
+
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    bool try_executing_one()
+    {
+      return false;
     }
 
     /**
@@ -143,7 +211,7 @@ namespace executors
      */
     void close()
     {
-      work_queue.close();
+      pimpl->close();
     }
 
     /**
@@ -151,7 +219,7 @@ namespace executors
      */
     bool closed()
     {
-      return work_queue.closed();
+      return pimpl->closed();
     }
 
     /**
@@ -165,47 +233,36 @@ namespace executors
      * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
      * Whatever exception that can be throw while storing the closure.
      */
-    void submit(BOOST_THREAD_RV_REF(work) closure)
-    {
-      work_queue.push(boost::move(closure));
-    }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <typename Closure>
     void submit(Closure & closure)
     {
-      submit(work(closure));
+      pimpl->submit(closure);
     }
 #endif
     void submit(void (*closure)())
     {
-      submit(work(closure));
+      pimpl->submit(closure);
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      work w((boost::forward<Closure>(closure)));
-      submit(boost::move(w));
+      pimpl->submit(boost::forward<Closure>(closure));
     }
 
     /**
-     * \b Requires: This must be called from an scheduled task.
-     *
-     * \b Effects: reschedule functions until pred()
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
      */
     template <typename Pred>
     bool reschedule_until(Pred const& pred)
     {
-      do {
-        if ( ! try_executing_one())
-        {
-          return false;
-        }
-      } while (! pred());
-      return true;
+      return false;
     }
-
+  private:
+    shared_ptr<shared_state> pimpl;
   };
 }
 using executors::serial_executor;

include/boost/thread/executors/serial_executor_cont.hpp

@@ -12,18 +12,20 @@
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
-#include <boost/thread/concurrent_queues/sync_queue.hpp>
 #include <boost/thread/executors/work.hpp>
-#include <boost/thread/executors/generic_executor_ref.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/thread/scoped_thread.hpp>
 
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
 {
 namespace executors
 {
+  template <class Executor>
   class serial_executor_cont
   {
   public:
@@ -31,93 +33,156 @@ namespace executors
     typedef  executors::work work;
   private:
 
-    generic_executor_ref ex_;
-    future<void> fut_; // protected by mtx_
-    bool closed_; // protected by mtx_
-    mutex mtx_;
+    struct shared_state {
+      typedef  executors::work work;
 
-    struct continuation {
-      work task;
-      template <class X>
-      struct result {
-        typedef void type;
-      };
-      continuation(BOOST_THREAD_RV_REF(work) tsk)
-      : task(boost::move(tsk)) {}
-      void operator()(future<void> f)
-      {
-        try {
-          task();
-        } catch (...)  {
-          std::terminate();
+      Executor ex_;
+      future<void> fut_; // protected by mtx_
+      bool closed_; // protected by mtx_
+      mutex mtx_;
+
+      struct continuation {
+        work task;
+        template <class X>
+        struct result {
+          typedef void type;
+        };
+        continuation(BOOST_THREAD_RV_REF(work) tsk)
+        : task(boost::move(tsk)) {}
+        void operator()(future<void> f)
+        {
+          try {
+            task();
+          } catch (...)  {
+            std::terminate();
+          }
         }
+      };
+
+      bool closed(lock_guard<mutex>&) const
+      {
+        return closed_;
+      }
+    public:
+      /**
+       * \par Returns
+       * The underlying executor wrapped on a generic executor reference.
+       */
+      Executor& underlying_executor() BOOST_NOEXCEPT { return ex_; }
+
+      /// shared_state is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a serial executor that runs closures in fifo order using one the associated executor.
+       *
+       * \b Throws: Whatever exception is thrown while initializing the needed resources.
+       *
+       * \b Notes:
+       * * The lifetime of the associated executor must outlive the serial executor.
+       * * The current implementation doesn't support submission from synchronous continuation, that is,
+       *     - the executor must execute the continuation asynchronously or
+       *     - the continuation can not submit to this serial executor.
+       */
+      shared_state(Executor& ex)
+      : ex_(ex), fut_(make_ready_future()), closed_(false)
+      {
+      }
+      /**
+       * \b Effects: Destroys the thread pool.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor_cont destructor.
+       */
+      ~shared_state()
+      {
+        // signal to the worker thread that there will be no more submissions.
+        close();
+      }
+
+      /**
+       * \b Effects: close the \c serial_executor_cont for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        lock_guard<mutex> lk(mtx_);
+        closed_ = true;;
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed()
+      {
+        lock_guard<mutex> lk(mtx_);
+        return closed(lk);
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution after the last submitted closure finish.
+       * If the invoked closure throws an exception the \c serial_executor_cont will call \c std::terminate, as is the case with threads.
+       *
+       * \b Throws: \c sync_queue_is_closed if the executor is closed.
+       * Whatever exception that can be throw while storing the closure.
+       *
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        fut_ = fut_.then(ex_, continuation(work(closure)));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        fut_ = fut_.then(ex_, continuation(work(closure)));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_RV_REF(Closure) closure)
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        fut_ = fut_.then(ex_, continuation(work(boost::forward<Closure>(closure))));
       }
     };
-
-    bool closed(lock_guard<mutex>&) const
-    {
-      return closed_;
-    }
   public:
     /**
-     * \par Returns
-     * The underlying executor wrapped on a generic executor reference.
-     */
-    generic_executor_ref& underlying_executor() BOOST_NOEXCEPT { return ex_; }
-
-    /// serial_executor_cont is not copyable.
-    BOOST_THREAD_NO_COPYABLE(serial_executor_cont)
-
-    /**
-     * \b Effects: creates a serial executor that runs closures in fifo order using one the associated executor.
+     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
      *
      * \b Throws: Whatever exception is thrown while initializing the needed resources.
-     *
-     * \b Notes:
-     * * The lifetime of the associated executor must outlive the serial executor.
-     * * The current implementation doesn't support submission from synchronous continuation, that is,
-     *     - the executor must execute the continuation asynchronously or
-     *     - the continuation can not submit to this serial executor.
      */
-    template <class Executor>
     serial_executor_cont(Executor& ex)
-    : ex_(ex), fut_(make_ready_future()), closed_(false)
+    : pimpl(make_shared<shared_state>(ex))
     {
     }
     /**
      * \b Effects: Destroys the thread pool.
      *
-     * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor_cont destructor.
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor destructor.
      */
     ~serial_executor_cont()
     {
-      // signal to the worker thread that there will be no more submissions.
-      close();
     }
 
     /**
-     * \b Effects: close the \c serial_executor_cont for submissions.
-     * The loop will work until there is no more closures to run.
+     * \par Returns
+     * The underlying executor wrapped on a generic executor reference.
      */
-    void close()
+    Executor& underlying_executor() BOOST_NOEXCEPT
     {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;;
+      return pimpl->underlying_executor();
     }
 
     /**
-     * \b Returns: whether the pool is closed for submissions.
-     */
-    bool closed()
-    {
-      lock_guard<mutex> lk(mtx_);
-      return closed(lk);
-    }
-
-    /**
-     * Effects: none.
-     * Returns: always false.
-     * Throws: No.
+     * \b Returns: always false as a serial executor can not re-enter.
      * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
      */
     bool try_executing_one()
@@ -125,41 +190,64 @@ namespace executors
       return false;
     }
 
+    /**
+     * \b Effects: close the \c serial_executor for submissions.
+     * The loop will work until there is no more closures to run.
+     */
+    void close()
+    {
+      pimpl->close();
+    }
+
+    /**
+     * \b Returns: whether the pool is closed for submissions.
+     */
+    bool closed()
+    {
+      return pimpl->closed();
+    }
+
     /**
      * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
      *
-     * \b Effects: The specified \c closure will be scheduled for execution after the last submitted closure finish.
-     * If the invoked closure throws an exception the \c serial_executor_cont will call \c std::terminate, as is the case with threads.
+     * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+     * If invoked closure throws an exception the \c serial_executor will call \c std::terminate, as is the case with threads.
      *
-     * \b Throws: \c sync_queue_is_closed if the executor is closed.
+     * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+     *
+     * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
      * Whatever exception that can be throw while storing the closure.
-     *
      */
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <typename Closure>
     void submit(Closure & closure)
     {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      fut_ = fut_.then(ex_, continuation(work(closure)));
+      pimpl->submit(closure);
     }
 #endif
     void submit(void (*closure)())
     {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      fut_ = fut_.then(ex_, continuation(work(closure)));
+      pimpl->submit(closure);
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))       BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      fut_ = fut_.then(ex_, continuation(work(boost::forward<Closure>(closure))));
+      pimpl->submit(boost::forward<Closure>(closure));
     }
 
+    /**
+     * \b Returns: always false as a serial executor can not re-enter.
+     * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
+     */
+    template <typename Pred>
+    bool reschedule_until(Pred const& pred)
+    {
+      return false;
+    }
+  private:
+    shared_ptr<shared_state> pimpl;
   };
 }
 using executors::serial_executor_cont;

include/boost/thread/executors/thread_executor.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-2015 Vicente J. Botet Escriba
 //
 //  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)
@@ -17,7 +17,9 @@
 #include <boost/thread/thread_only.hpp>
 #include <boost/thread/scoped_thread.hpp>
 #include <boost/thread/csbl/vector.hpp>
-#include <boost/thread/concurrent_queues/queue_op_status.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -30,33 +32,134 @@ namespace executors
   public:
     /// type-erasure to store the works to do
     typedef  executors::work work;
-    bool closed_;
-    typedef scoped_thread<> thread_t;
-    typedef csbl::vector<thread_t> threads_type;
-    threads_type threads_;
-    mutable mutex mtx_;
+  private:
 
-    /**
-     * Effects: try to execute one task.
-     * Returns: whether a task has been executed.
-     * Throws: whatever the current task constructor throws or the task() throws.
-     */
-    bool try_executing_one()
-    {
-      return false;
-    }
+    struct shared_state {
+      typedef  executors::work work;
+      bool closed_;
+      typedef scoped_thread<> thread_t;
+      typedef csbl::vector<thread_t> threads_type;
+      threads_type threads_;
+      mutable mutex mtx_;
 
+      /// thread_executor is not copyable.
+      BOOST_THREAD_NO_COPYABLE(shared_state)
+
+      /**
+       * \b Effects: creates a inline executor that runs closures immediately.
+       *
+       * \b Throws: Nothing.
+       */
+      shared_state()
+      : closed_(false)
+      {
+      }
+      /**
+       * \b Effects: Waits for closures (if any) to complete, then joins and destroys the threads.
+       *
+       * \b Synchronization: The completion of all the closures happen before the completion of the \c thread_executor destructor.
+       */
+      ~shared_state()
+      {
+        // signal to all the worker thread that there will be no more submissions.
+        close();
+        // all the scoped threads will join before destroying
+      }
+
+      /**
+       * Effects: try to execute one task.
+       * Returns: whether a task has been executed.
+       * Throws: whatever the current task constructor throws or the task() throws.
+       */
+      bool try_executing_one()
+      {
+        return false;
+      }
+
+      /**
+       * \b Effects: close the \c thread_executor for submissions.
+       * The loop will work until there is no more closures to run.
+       */
+      void close()
+      {
+        lock_guard<mutex> lk(mtx_);
+        closed_ = true;
+      }
+
+      /**
+       * \b Returns: whether the pool is closed for submissions.
+       */
+      bool closed(lock_guard<mutex>& )
+      {
+        return closed_;
+      }
+      bool closed()
+      {
+        lock_guard<mutex> lk(mtx_);
+        return closed(lk);
+      }
+
+      /**
+       * \b Requires: \c Closure is a model of \c Callable(void()) and a model of \c CopyConstructible/MoveConstructible.
+       *
+       * \b Effects: The specified \c closure will be scheduled for execution at some point in the future.
+       * If invoked closure throws an exception the \c thread_executor will call \c std::terminate, as is the case with threads.
+       *
+       * \b Synchronization: completion of \c closure on a particular thread happens before destruction of thread's thread local variables.
+       *
+       * \b Throws: \c sync_queue_is_closed if the thread pool is closed.
+       * Whatever exception that can be throw while storing the closure.
+       */
+
+  #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename Closure>
+      void submit(Closure & closure)
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        threads_.reserve(threads_.size() + 1);
+        thread th(closure);
+        threads_.push_back(thread_t(boost::move(th)));
+      }
+  #endif
+      void submit(void (*closure)())
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        threads_.reserve(threads_.size() + 1);
+        thread th(closure);
+        threads_.push_back(thread_t(boost::move(th)));
+      }
+
+      template <typename Closure>
+      void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+      {
+        lock_guard<mutex> lk(mtx_);
+        if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
+        threads_.reserve(threads_.size() + 1);
+        thread th(boost::forward<Closure>(closure));
+        threads_.push_back(thread_t(boost::move(th)));
+      }
+
+      /**
+       * \b Requires: This must be called from an scheduled task.
+       *
+       * \b Effects: reschedule functions until pred()
+       */
+      template <typename Pred>
+      bool reschedule_until(Pred const&)
+      {
+        return false;
+      }
+    };
   public:
-    /// thread_executor is not copyable.
-    BOOST_THREAD_NO_COPYABLE(thread_executor)
-
     /**
      * \b Effects: creates a inline executor that runs closures immediately.
      *
      * \b Throws: Nothing.
      */
     thread_executor()
-    : closed_(false)
+    : pimpl(make_shared<shared_state>())
     {
     }
     /**
@@ -66,9 +169,16 @@ namespace executors
      */
     ~thread_executor()
     {
-      // signal to all the worker thread that there will be no more submissions.
-      close();
-      // all the scoped threads will join before destroying
+    }
+
+    /**
+     * Effects: try to execute one task.
+     * Returns: whether a task has been executed.
+     * Throws: whatever the current task constructor throws or the task() throws.
+     */
+    bool try_executing_one()
+    {
+      return pimpl->try_executing_one();
     }
 
     /**
@@ -77,21 +187,15 @@ namespace executors
      */
     void close()
     {
-      lock_guard<mutex> lk(mtx_);
-      closed_ = true;
+      pimpl->close();
     }
 
     /**
      * \b Returns: whether the pool is closed for submissions.
      */
-    bool closed(lock_guard<mutex>& )
-    {
-      return closed_;
-    }
     bool closed()
     {
-      lock_guard<mutex> lk(mtx_);
-      return closed(lk);
+      return pimpl->closed();
     }
 
     /**
@@ -110,30 +214,18 @@ namespace executors
     template <typename Closure>
     void submit(Closure & closure)
     {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      threads_.reserve(threads_.size() + 1);
-      thread th(closure);
-      threads_.push_back(thread_t(boost::move(th)));
+      pimpl->submit(closure);
     }
 #endif
     void submit(void (*closure)())
     {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      threads_.reserve(threads_.size() + 1);
-      thread th(closure);
-      threads_.push_back(thread_t(boost::move(th)));
+      pimpl->submit(closure);
     }
 
     template <typename Closure>
     void submit(BOOST_THREAD_FWD_REF(Closure) closure)
     {
-      lock_guard<mutex> lk(mtx_);
-      if (closed(lk))  BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
-      threads_.reserve(threads_.size() + 1);
-      thread th(boost::forward<Closure>(closure));
-      threads_.push_back(thread_t(boost::move(th)));
+      pimpl->submit(boost::forward<Closure>(closure));
     }
 
     /**
@@ -142,12 +234,14 @@ namespace executors
      * \b Effects: reschedule functions until pred()
      */
     template <typename Pred>
-    bool reschedule_until(Pred const&)
+    bool reschedule_until(Pred const& p)
     {
-      return false;
+      return pimpl->reschedule_until(p);
     }
-
+  private:
+    shared_ptr<shared_state> pimpl;
   };
+
 }
 using executors::thread_executor;
 }

include/boost/thread/experimental/parallel/v2/task_region.hpp

@@ -53,7 +53,7 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)
         throw;
       }
 #if defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED
-      catch (task_canceled_exception&)
+      catch (task_canceled_exception& ex)
       {
       }
 #endif
@@ -116,9 +116,9 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)
     template<typename F>
     friend void task_region_final(BOOST_THREAD_FWD_REF(F) f);
     template <class Ex, typename F>
-    friend void task_region(Ex&, BOOST_THREAD_FWD_REF(F) f);
+    friend void task_region(Ex const&, BOOST_THREAD_FWD_REF(F) f);
     template<class Ex, typename F>
-    friend void task_region_final(Ex&, BOOST_THREAD_FWD_REF(F) f);
+    friend void task_region_final(Ex const&, BOOST_THREAD_FWD_REF(F) f);
 
     void wait_all()
     {
@@ -153,21 +153,20 @@ protected:
 #if defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED && defined BOOST_THREAD_PROVIDES_EXECUTORS
     task_region_handle_gen()
     : canceled(false)
-    , ex(0)
     {}
-    task_region_handle_gen(Executor& ex)
+    task_region_handle_gen(Executor const& ex)
     : canceled(false)
-    , ex(&ex)
+    , ex(ex)
     {}
 
 #endif
 
 #if ! defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED && defined BOOST_THREAD_PROVIDES_EXECUTORS
     task_region_handle_gen()
-    : ex(0)
+    //: ex(0)
     {}
-    task_region_handle_gen(Executor& ex)
-    : ex(&ex)
+    task_region_handle_gen(Executor const& ex)
+    : ex(ex)
     {}
 #endif
 
@@ -188,7 +187,7 @@ protected:
     bool canceled;
 #endif
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
-    Executor* ex;
+    Executor ex;
 #endif
     exception_list exs;
     typedef csbl::vector<future<void> > group_type;
@@ -211,13 +210,13 @@ protected:
         }
       }
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
-      group.push_back(async(*ex, detail::wrapped<task_region_handle_gen<Executor>, F>(*this, forward<F>(f))));
+      group.push_back(async(ex, detail::wrapped<task_region_handle_gen<Executor>, F>(*this, forward<F>(f))));
 #else
       group.push_back(async(detail::wrapped<task_region_handle_gen<Executor>, F>(*this, forward<F>(f))));
 #endif
 #else
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
-      group.push_back(async(*ex, forward<F>(f)));
+      group.push_back(async(ex, forward<F>(f)));
 #else
       group.push_back(async(forward<F>(f)));
 #endif
@@ -245,17 +244,18 @@ protected:
   class task_region_handle :
     public task_region_handle_gen<default_executor>
   {
-    default_executor tp;
+    //default_executor tp;
     template <typename F>
     friend void task_region(BOOST_THREAD_FWD_REF(F) f);
     template<typename F>
     friend void task_region_final(BOOST_THREAD_FWD_REF(F) f);
 
   protected:
-    task_region_handle() : task_region_handle_gen<default_executor>()
+    task_region_handle()
+    : task_region_handle_gen<default_executor>()
     {
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
-      ex = &tp;
+      //ex = &tp;
 #endif
     }
     BOOST_DELETED_FUNCTION(task_region_handle(const task_region_handle&))
@@ -265,7 +265,7 @@ protected:
   };
 
   template <typename Executor, typename F>
-  void task_region_final(Executor& ex, BOOST_THREAD_FWD_REF(F) f)
+  void task_region_final(Executor const& ex, BOOST_THREAD_FWD_REF(F) f)
   {
     task_region_handle_gen<Executor> tr(ex);
     try
@@ -280,7 +280,7 @@ protected:
   }
 
   template <typename Executor, typename F>
-  void task_region(Executor& ex, BOOST_THREAD_FWD_REF(F) f)
+  void task_region(Executor const& ex, BOOST_THREAD_FWD_REF(F) f)
   {
     task_region_final(ex, forward<F>(f));
   }

include/boost/thread/futures/launch.hpp

@@ -22,8 +22,6 @@ namespace boost
 #ifdef BOOST_THREAD_PROVIDES_EXECUTORS
       executor = 4,
 #endif
-      inherit = 8,
-      sync = 16,
       any = async | deferred
   }
   BOOST_SCOPED_ENUM_DECLARE_END(launch)

include/boost/thread/latch.hpp

@@ -72,7 +72,6 @@ namespace boost
     void wait()
     {
       boost::unique_lock<boost::mutex> lk(mutex_);
-      if (count_ == 0) return;
       std::size_t generation(generation_);
       cond_.wait(lk, detail::not_equal(generation, generation_));
     }
@@ -90,7 +89,6 @@ namespace boost
     cv_status wait_for(const chrono::duration<Rep, Period>& rel_time)
     {
       boost::unique_lock<boost::mutex> lk(mutex_);
-      if (count_ == 0) return cv_status::no_timeout;
       std::size_t generation(generation_);
       return cond_.wait_for(lk, rel_time, detail::not_equal(generation, generation_))
               ? cv_status::no_timeout
@@ -103,7 +101,6 @@ namespace boost
     cv_status wait_until(const chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<boost::mutex> lk(mutex_);
-      if (count_ == 0) return cv_status::no_timeout;
       std::size_t generation(generation_);
       return cond_.wait_until(lk, abs_time, detail::not_equal(generation, generation_))
           ? cv_status::no_timeout

include/boost/thread/poly_lockable.hpp

@@ -31,7 +31,7 @@ namespace boost
   //]
 
   //[poly_lockable
-  class poly_lockable : public basic_poly_lockable
+  class poly_lockable : public basic_poly_lockable<Lockable>
   {
   public:
 
@@ -41,7 +41,7 @@ namespace boost
   //]
 
   //[timed_poly_lockable
-  class timed_poly_lockable: public poly_lockable
+  class timed_poly_lockable: public poly_lockable<TimedLock>
   {
   public:
     virtual ~timed_poly_lockable()=0;

include/boost/thread/pthread/condition_variable.hpp

@@ -68,14 +68,17 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
             detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
-            pthread_mutex_t* the_mutex = &internal_mutex;
             guard.activate(m);
+            do {
+              res = pthread_cond_wait(&cond,&internal_mutex);
+            } while (res == EINTR);
 #else
+            //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
             pthread_mutex_t* the_mutex = m.mutex()->native_handle();
-#endif
             do {
               res = pthread_cond_wait(&cond,the_mutex);
             } while (res == EINTR);
+#endif
         }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         this_thread::interruption_point();
@@ -96,17 +99,18 @@ namespace boost
             boost::throw_exception(condition_error(EPERM, "boost::condition_variable::do_wait_until() failed precondition mutex not owned"));
         }
 #endif
+        thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
         int cond_res;
         {
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
             detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
-            pthread_mutex_t* the_mutex = &internal_mutex;
             guard.activate(m);
+            cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
 #else
+            //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
             pthread_mutex_t* the_mutex = m.mutex()->native_handle();
-#endif
             cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
+#endif
         }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         this_thread::interruption_point();
@@ -152,11 +156,11 @@ namespace boost
             {
                 boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init"));
             }
-            int const res2 = detail::monotonic_pthread_cond_init(cond);
+            int const res2=pthread_cond_init(&cond,NULL);
             if(res2)
             {
                 BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-                boost::throw_exception(thread_resource_error(res2, "boost::condition_variable_any::condition_variable_any() failed in detail::monotonic_pthread_cond_init"));
+                boost::throw_exception(thread_resource_error(res2, "boost::condition_variable_any::condition_variable_any() failed in pthread_cond_init"));
             }
         }
         ~condition_variable_any()
@@ -174,7 +178,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
 #else
-                boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+            boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
 #endif
                 guard.activate(m);
                 res=pthread_cond_wait(&cond,&internal_mutex);
@@ -236,8 +240,6 @@ namespace boost
             return timed_wait(m,get_system_time()+wait_duration,pred);
         }
 #endif
-#ifndef BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class lock_type,class Duration>
         cv_status
@@ -266,91 +268,6 @@ namespace boost
           return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
         }
 
-        template <class lock_type, class Rep, class Period>
-        cv_status
-        wait_for(
-                lock_type& lock,
-                const chrono::duration<Rep, Period>& d)
-        {
-          using namespace chrono;
-          system_clock::time_point s_now = system_clock::now();
-          steady_clock::time_point c_now = steady_clock::now();
-          wait_until(lock, s_now + ceil<nanoseconds>(d));
-          return steady_clock::now() - c_now < d ? cv_status::no_timeout :
-                                                   cv_status::timeout;
-
-        }
-
-        template <class lock_type>
-        cv_status wait_until(
-            lock_type& lk,
-            chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
-        {
-            using namespace chrono;
-            nanoseconds d = tp.time_since_epoch();
-            timespec ts = boost::detail::to_timespec(d);
-            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
-            else return cv_status::timeout;
-        }
-#endif
-#else // defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-#ifdef BOOST_THREAD_USES_CHRONO
-
-        template <class lock_type, class Duration>
-        cv_status
-        wait_until(
-            lock_type& lock,
-            const chrono::time_point<chrono::steady_clock, Duration>& t)
-        {
-            using namespace chrono;
-            typedef time_point<steady_clock, nanoseconds> nano_sys_tmpt;
-            wait_until(lock,
-                        nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
-            return steady_clock::now() < t ? cv_status::no_timeout :
-                                             cv_status::timeout;
-        }
-
-        template <class lock_type, class Clock, class Duration>
-        cv_status
-        wait_until(
-            lock_type& lock,
-            const chrono::time_point<Clock, Duration>& t)
-        {
-            using namespace chrono;
-            steady_clock::time_point     s_now = steady_clock::now();
-            typename Clock::time_point  c_now = Clock::now();
-            wait_until(lock, s_now + ceil<nanoseconds>(t - c_now));
-            return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
-        }
-
-        template <class lock_type, class Rep, class Period>
-        cv_status
-        wait_for(
-            lock_type& lock,
-            const chrono::duration<Rep, Period>& d)
-        {
-            using namespace chrono;
-            steady_clock::time_point c_now = steady_clock::now();
-            wait_until(lock, c_now + ceil<nanoseconds>(d));
-            return steady_clock::now() - c_now < d ? cv_status::no_timeout :
-                                                   cv_status::timeout;
-        }
-
-        inline cv_status wait_until(
-            unique_lock<mutex>& lk,
-            chrono::time_point<chrono::steady_clock, chrono::nanoseconds> tp)
-        {
-            using namespace chrono;
-            nanoseconds d = tp.time_since_epoch();
-            timespec ts = boost::detail::to_timespec(d);
-            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
-            else return cv_status::timeout;
-        }
-
-#endif
-#endif // defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
-#ifdef BOOST_THREAD_USES_CHRONO
         template <class lock_type, class Clock, class Duration, class Predicate>
         bool
         wait_until(
@@ -366,6 +283,23 @@ namespace boost
             return true;
         }
 
+
+        template <class lock_type, class Rep, class Period>
+        cv_status
+        wait_for(
+                lock_type& lock,
+                const chrono::duration<Rep, Period>& d)
+        {
+          using namespace chrono;
+          system_clock::time_point s_now = system_clock::now();
+          steady_clock::time_point c_now = steady_clock::now();
+          wait_until(lock, s_now + ceil<nanoseconds>(d));
+          return steady_clock::now() - c_now < d ? cv_status::no_timeout :
+                                                   cv_status::timeout;
+
+        }
+
+
         template <class lock_type, class Rep, class Period, class Predicate>
         bool
         wait_for(
@@ -374,6 +308,25 @@ namespace boost
                 Predicate pred)
         {
           return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
+
+//          while (!pred())
+//          {
+//              if (wait_for(lock, d) == cv_status::timeout)
+//                  return pred();
+//          }
+//          return true;
+        }
+
+        template <class lock_type>
+        cv_status wait_until(
+            lock_type& lk,
+            chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
+        {
+            using namespace chrono;
+            nanoseconds d = tp.time_since_epoch();
+            timespec ts = boost::detail::to_timespec(d);
+            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
+            else return cv_status::timeout;
         }
 #endif
 
@@ -401,7 +354,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
               detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
 #else
-              boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+            boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
 #endif
               guard.activate(m);
               res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
@@ -419,6 +372,8 @@ namespace boost
           }
           return true;
         }
+
+
     };
 
 }

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -28,26 +28,6 @@
 
 namespace boost
 {
-  namespace detail {
-    inline int monotonic_pthread_cond_init(pthread_cond_t& cond) {
-
-#ifdef BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-            pthread_condattr_t attr;
-            int res = pthread_condattr_init(&attr);
-            if (res)
-            {
-              return res;
-            }
-            pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
-            res=pthread_cond_init(&cond,&attr);
-            pthread_condattr_destroy(&attr);
-            return res;
-#else
-            return pthread_cond_init(&cond,NULL);
-#endif
-
-    }
-  }
 
     class condition_variable
     {
@@ -76,19 +56,19 @@ namespace boost
         condition_variable()
         {
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            int res=pthread_mutex_init(&internal_mutex,NULL);
+            int const res=pthread_mutex_init(&internal_mutex,NULL);
             if(res)
             {
                 boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
             }
 #endif
-            res = detail::monotonic_pthread_cond_init(cond);
-            if (res)
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
             {
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
 #endif
-                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in detail::monotonic_pthread_cond_init"));
+                boost::throw_exception(thread_resource_error(res2, "boost::condition_variable::condition_variable() constructor failed in pthread_cond_init"));
             }
         }
         ~condition_variable()
@@ -114,6 +94,7 @@ namespace boost
             while(!pred()) wait(m);
         }
 
+
 #if defined BOOST_THREAD_USES_DATETIME
         inline bool timed_wait(
             unique_lock<mutex>& m,
@@ -193,8 +174,6 @@ namespace boost
         }
 #endif
 
-#ifndef BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
 #ifdef BOOST_THREAD_USES_CHRONO
 
         template <class Duration>
@@ -224,6 +203,20 @@ namespace boost
           return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
         }
 
+        template <class Clock, class Duration, class Predicate>
+        bool
+        wait_until(
+                unique_lock<mutex>& lock,
+                const chrono::time_point<Clock, Duration>& t,
+                Predicate pred)
+        {
+            while (!pred())
+            {
+                if (wait_until(lock, t) == cv_status::timeout)
+                    return pred();
+            }
+            return true;
+        }
 
 
         template <class Rep, class Period>
@@ -241,90 +234,6 @@ namespace boost
 
         }
 
-        inline cv_status wait_until(
-            unique_lock<mutex>& lk,
-            chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
-        {
-            using namespace chrono;
-            nanoseconds d = tp.time_since_epoch();
-            timespec ts = boost::detail::to_timespec(d);
-            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
-            else return cv_status::timeout;
-        }
-#endif
-
-#else // defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-#ifdef BOOST_THREAD_USES_CHRONO
-
-        template <class Duration>
-        cv_status
-        wait_until(
-              unique_lock<mutex>& lock,
-              const chrono::time_point<chrono::steady_clock, Duration>& t)
-        {
-            using namespace chrono;
-            typedef time_point<steady_clock, nanoseconds> nano_sys_tmpt;
-            wait_until(lock,
-                        nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
-            return steady_clock::now() < t ? cv_status::no_timeout :
-                                             cv_status::timeout;
-        }
-
-        template <class Clock, class Duration>
-        cv_status
-        wait_until(
-            unique_lock<mutex>& lock,
-            const chrono::time_point<Clock, Duration>& t)
-        {
-            using namespace chrono;
-            steady_clock::time_point     s_now = steady_clock::now();
-            typename Clock::time_point  c_now = Clock::now();
-            wait_until(lock, s_now + ceil<nanoseconds>(t - c_now));
-            return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
-        }
-
-        template <class Rep, class Period>
-        cv_status
-        wait_for(
-            unique_lock<mutex>& lock,
-            const chrono::duration<Rep, Period>& d)
-        {
-            using namespace chrono;
-            steady_clock::time_point c_now = steady_clock::now();
-            wait_until(lock, c_now + ceil<nanoseconds>(d));
-            return steady_clock::now() - c_now < d ? cv_status::no_timeout :
-                                                   cv_status::timeout;
-        }
-
-        inline cv_status wait_until(
-            unique_lock<mutex>& lk,
-            chrono::time_point<chrono::steady_clock, chrono::nanoseconds> tp)
-        {
-            using namespace chrono;
-            nanoseconds d = tp.time_since_epoch();
-            timespec ts = boost::detail::to_timespec(d);
-            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
-            else return cv_status::timeout;
-        }
-#endif
-
-#endif // defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Clock, class Duration, class Predicate>
-        bool
-        wait_until(
-                unique_lock<mutex>& lock,
-                const chrono::time_point<Clock, Duration>& t,
-                Predicate pred)
-        {
-            while (!pred())
-            {
-                if (wait_until(lock, t) == cv_status::timeout)
-                    return pred();
-            }
-            return true;
-        }
 
         template <class Rep, class Period, class Predicate>
         bool
@@ -334,6 +243,13 @@ namespace boost
                 Predicate pred)
         {
           return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
+
+//          while (!pred())
+//          {
+//              if (wait_for(lock, d) == cv_status::timeout)
+//                  return pred();
+//          }
+//          return true;
         }
 #endif
 
@@ -347,7 +263,18 @@ namespace boost
         void notify_one() BOOST_NOEXCEPT;
         void notify_all() BOOST_NOEXCEPT;
 
-
+#ifdef BOOST_THREAD_USES_CHRONO
+        inline cv_status wait_until(
+            unique_lock<mutex>& lk,
+            chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
+        {
+            using namespace chrono;
+            nanoseconds d = tp.time_since_epoch();
+            timespec ts = boost::detail::to_timespec(d);
+            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
+            else return cv_status::timeout;
+        }
+#endif
     };
 
     BOOST_THREAD_DECL void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);

include/boost/thread/pthread/once_atomic.hpp

@@ -214,7 +214,7 @@ namespace boost
       thread_detail::commit_once_region(flag);
     }
   }
-#if !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
+
   template<typename Function>
   inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f)
   {
@@ -302,7 +302,7 @@ namespace boost
     }
   }
 
-#endif // __SUNPRO_CC
+
 
 #endif
 }

include/boost/thread/shared_mutex.hpp

@@ -28,7 +28,6 @@
 
 namespace boost
 {
-  typedef shared_mutex shared_timed_mutex;
   namespace sync
   {
 #ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES

include/boost/thread/v2/thread.hpp

@@ -91,19 +91,7 @@ namespace boost
         cv.wait_until(lk, t);
     }
 
-#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC && defined BOOST_CHRONO_HAS_CLOCK_STEADY
-    template <class Rep, class Period>
-    void sleep_for(const chrono::duration<Rep, Period>& d)
-    {
-      using namespace chrono;
-      if (d > duration<Rep, Period>::zero())
-      {
-        steady_clock::time_point c_timeout = steady_clock::now() + ceil<nanoseconds>(d);
-        sleep_until(c_timeout);
-      }
-    }
-
-#elif defined BOOST_THREAD_SLEEP_FOR_IS_STEADY
+#ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY
 
     template <class Rep, class Period>
     void sleep_for(const chrono::duration<Rep, Period>& d)
@@ -139,8 +127,7 @@ namespace boost
       using namespace chrono;
       if (d > duration<Rep, Period>::zero())
       {
-        //system_clock::time_point c_timeout = time_point_cast<system_clock::duration>(system_clock::now() + ceil<nanoseconds>(d));
-        system_clock::time_point c_timeout = system_clock::now() + ceil<system_clock::duration>(d);
+        steady_clock::time_point c_timeout = steady_clock::now() + ceil<nanoseconds>(d);
         sleep_until(c_timeout);
       }
     }

include/boost/thread/win32/shared_mutex.hpp

@@ -139,7 +139,6 @@ namespace boost
 
         void lock_shared()
         {
-
 #if defined BOOST_THREAD_USES_DATETIME
             BOOST_VERIFY(timed_lock_shared(::boost::detail::get_system_time_sentinel()));
 #else
@@ -390,7 +389,6 @@ namespace boost
 
         void lock()
         {
-
 #if defined BOOST_THREAD_USES_DATETIME
             BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
 #else
@@ -741,7 +739,6 @@ namespace boost
                 new_state.upgrade=false;
                 bool const last_reader=!--new_state.shared_count;
 
-                new_state.shared_waiting=0;
                 if(last_reader)
                 {
                     if(new_state.exclusive_waiting)
@@ -749,6 +746,7 @@ namespace boost
                         --new_state.exclusive_waiting;
                         new_state.exclusive_waiting_blocked=false;
                     }
+                    new_state.shared_waiting=0;
                 }
 
                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);

include/boost/thread/win32/thread_data.hpp

@@ -280,13 +280,12 @@ namespace boost
         {
             interruptible_wait(abs_time);
         }
-// #11322   sleep_for() nanoseconds overload will always return too early on windows
-//#ifdef BOOST_THREAD_USES_CHRONO
-//        inline void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns)
-//        {
-//          interruptible_wait(chrono::duration_cast<chrono::milliseconds>(ns).count());
-//        }
-//#endif
+#ifdef BOOST_THREAD_USES_CHRONO
+        inline void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns)
+        {
+          interruptible_wait(chrono::duration_cast<chrono::milliseconds>(ns).count());
+        }
+#endif
         namespace no_interruption_point
         {
           bool BOOST_THREAD_DECL non_interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time);
@@ -307,13 +306,12 @@ namespace boost
           {
             non_interruptible_wait(abs_time);
           }
-// #11322   sleep_for() nanoseconds overload will always return too early on windows
-//#ifdef BOOST_THREAD_USES_CHRONO
-//          inline void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns)
-//          {
-//            non_interruptible_wait(chrono::duration_cast<chrono::milliseconds>(ns).count());
-//          }
-//#endif
+#ifdef BOOST_THREAD_USES_CHRONO
+          inline void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns)
+          {
+            non_interruptible_wait(chrono::duration_cast<chrono::milliseconds>(ns).count());
+          }
+#endif
         }
     }
 

include/boost/thread/win32/thread_primitives.hpp

@@ -46,7 +46,7 @@ namespace boost
             unsigned const create_event_manual_reset = 0x00000001;
             unsigned const event_all_access = EVENT_ALL_ACCESS;
             unsigned const semaphore_all_access = SEMAPHORE_ALL_ACCESS;
-
+            
 
 # ifdef BOOST_NO_ANSI_APIS
 # if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
@@ -59,7 +59,7 @@ namespace boost
             using ::CreateSemaphoreExW;
 # endif
             using ::OpenEventW;
-            using ::GetModuleHandleW;
+            using ::GetModuleGandleW;
 # else
             using ::CreateMutexA;
             using ::CreateEventA;
@@ -79,8 +79,8 @@ namespace boost
             using ::ReleaseSemaphore;
             using ::SetEvent;
             using ::ResetEvent;
-            using ::WaitForMultipleObjectsEx;
-            using ::WaitForSingleObjectEx;
+            using ::WaitForMultipleObjectsEx;  
+            using ::WaitForSingleObjectEx;  
             using ::GetCurrentProcessId;
             using ::GetCurrentThreadId;
             using ::GetCurrentThread;
@@ -91,7 +91,7 @@ namespace boost
             using ::Sleep;
             using ::QueueUserAPC;
             using ::GetProcAddress;
-#endif
+#endif           
         }
     }
 }
@@ -286,7 +286,7 @@ namespace boost
                 }
 
                 // Oops, we weren't called often enough, we're stuck
-                return 0xFFFFFFFF;
+                return 0xFFFFFFFF;     
             }
 #else
 #endif
@@ -295,12 +295,12 @@ namespace boost
                 static detail::gettickcount64_t gettickcount64impl;
                 if(gettickcount64impl)
                     return gettickcount64impl;
-
+                    
                 // GetTickCount and GetModuleHandle are not allowed in the Windows Runtime,
                 // and kernel32 isn't used in Windows Phone.
 #if BOOST_PLAT_WINDOWS_RUNTIME
                 gettickcount64impl = &GetTickCount64;
-#else
+#else               
                 farproc_t addr=GetProcAddress(
 #if !defined(BOOST_NO_ANSI_APIS)
                     GetModuleHandleA("KERNEL32.DLL"),
@@ -312,7 +312,7 @@ namespace boost
                     gettickcount64impl=(detail::gettickcount64_t) addr;
                 else
                     gettickcount64impl=&GetTickCount64emulation;
-#endif
+#endif                    
                 return gettickcount64impl;
             }
 
@@ -343,14 +343,14 @@ namespace boost
                 handle const res = win32::CreateEventW(0, type, state, mutex_name);
 #else
                 handle const res = win32::CreateEventExW(
-                    0,
-                    mutex_name,
+                    0, 
+                    mutex_name, 
                     type ? create_event_manual_reset : 0 | state ? create_event_initial_set : 0,
                     event_all_access);
 #endif
                 return res;
             }
-
+            
             inline handle create_anonymous_event(event_type type,initial_event_state state)
             {
                 handle const res = create_event(0, type, state);
@@ -374,7 +374,7 @@ namespace boost
 #endif
                 return res;
             }
-
+      
             inline handle create_anonymous_semaphore(long initial_count,long max_count)
             {
                 handle const res=create_anonymous_semaphore_nothrow(initial_count,max_count);
@@ -402,20 +402,20 @@ namespace boost
             {
                 BOOST_VERIFY(ReleaseSemaphore(semaphore,count,0)!=0);
             }
-
+            
             inline void get_system_info(system_info *info)
             {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                win32::GetNativeSystemInfo(info);
+                win32::GetNativeSystemInfo(info); 
 #else
                 win32::GetSystemInfo(info);
 #endif
             }
-
+            
             inline void sleep(unsigned long milliseconds)
             {
                 if(milliseconds == 0)
-                {
+                {                
 #if BOOST_PLAT_WINDOWS_RUNTIME
                     std::this_thread::yield();
 #else
@@ -425,13 +425,13 @@ namespace boost
                 else
                 {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                    ::boost::detail::win32::WaitForSingleObjectEx(::boost::detail::win32::GetCurrentThread(), milliseconds, 0);
+                    ::boost::detail::win32::WaitForSingleObjectEx(::boost::detail::win32::GetCurrentThread(), milliseconds, 0); 
 #else
                     ::boost::detail::win32::Sleep(milliseconds);
 #endif
                 }
             }
-
+            
 #if BOOST_PLAT_WINDOWS_RUNTIME
             class BOOST_THREAD_DECL scoped_winrt_thread
             {
@@ -639,7 +639,7 @@ namespace boost
                     }
                     old=current;
                 }
-                while(true) ;
+                while(true);
                 return (old&value)!=0;
             }
 
@@ -656,7 +656,7 @@ namespace boost
                     }
                     old=current;
                 }
-                while(true) ;
+                while(true);
                 return (old&value)!=0;
             }
         }

src/pthread/once.cpp

@@ -15,7 +15,9 @@
 #include <pthread.h>
 #include <stdlib.h>
 #include <memory>
+#if defined BOOST_THREAD_PATCH
 #include <string.h> // memcmp.
+#endif
 namespace boost
 {
     namespace thread_detail
@@ -42,6 +44,7 @@ namespace boost
                 }
             }
 
+#if defined BOOST_THREAD_PATCH
             const pthread_once_t pthread_once_init_value=PTHREAD_ONCE_INIT;
             struct BOOST_THREAD_DECL delete_epoch_tss_key_on_dlclose_t
             {
@@ -57,6 +60,7 @@ namespace boost
                 }
             };
             delete_epoch_tss_key_on_dlclose_t delete_epoch_tss_key_on_dlclose;
+#endif
         }
 
         uintmax_atomic_t& get_once_per_thread_epoch()

src/pthread/thread.cpp

@@ -35,7 +35,6 @@
 #include <string>
 #include <set>
 #include <vector>
-#include <string.h> // memcmp.
 
 namespace boost
 {
@@ -80,8 +79,8 @@ namespace boost
             {
                 static void tls_destructor(void* data)
                 {
-                    //boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
-                    boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(data)->shared_from_this();
+                    boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
+                    //boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(data)->shared_from_this();
 
                     if(thread_info)
                     {
@@ -110,11 +109,16 @@ namespace boost
                                 thread_info->tss_data.erase(current);
                             }
                         }
-                        thread_info->self.reset();
+                        if (thread_info) // fixme: should we test this?
+                        {
+                          thread_info->self.reset();
+                        }
                     }
                 }
             }
 
+#if defined BOOST_THREAD_PATCH
+
             struct  delete_current_thread_tls_key_on_dlclose_t
             {
                 delete_current_thread_tls_key_on_dlclose_t()
@@ -130,6 +134,7 @@ namespace boost
                 }
             };
             delete_current_thread_tls_key_on_dlclose_t delete_current_thread_tls_key_on_dlclose;
+#endif
 
             void create_current_thread_tls_key()
             {

src/win32/thread.cpp

@@ -25,7 +25,6 @@
 #if defined BOOST_THREAD_USES_DATETIME
 #include <boost/date_time/posix_time/conversion.hpp>
 #endif
-#include <boost/thread/csbl/memory/unique_ptr.hpp>
 #include <memory>
 #include <algorithm>
 #ifndef UNDER_CE
@@ -154,7 +153,7 @@ namespace boost
 
         DWORD WINAPI ThreadProxy(LPVOID args)
         {
-            boost::csbl::unique_ptr<ThreadProxyData> data(reinterpret_cast<ThreadProxyData*>(args));
+            std::auto_ptr<ThreadProxyData> data(reinterpret_cast<ThreadProxyData*>(args));
             DWORD ret=data->start_address_(data->arglist_);
             return ret;
         }
@@ -527,11 +526,8 @@ namespace boost
 
     unsigned thread::physical_concurrency() BOOST_NOEXCEPT
     {
-      // a bit too strict: Windows XP with SP3 would be sufficient
-#if BOOST_PLAT_WINDOWS_RUNTIME                                    \
-    || ( BOOST_USE_WINAPI_VERSION <= BOOST_WINAPI_VERSION_WINXP ) \
-    || ( ( defined(__MINGW32__) && !defined(__MINGW64__) ) && _WIN32_WINNT < 0x0600)
-        return 0;
+#if BOOST_PLAT_WINDOWS_RUNTIME || (defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR))
+        return hardware_concurrency();
 #else
         unsigned cores = 0;
         DWORD size = 0;
@@ -649,7 +645,7 @@ namespace boost
                     } Detailed;
                 } Reason;
             } REASON_CONTEXT, *PREASON_CONTEXT;
-            //static REASON_CONTEXT default_reason_context={0/*POWER_REQUEST_CONTEXT_VERSION*/, 0x00000001/*POWER_REQUEST_CONTEXT_SIMPLE_STRING*/, (LPWSTR)L"generic"};
+            static REASON_CONTEXT default_reason_context={0/*POWER_REQUEST_CONTEXT_VERSION*/, 0x00000001/*POWER_REQUEST_CONTEXT_SIMPLE_STRING*/, (LPWSTR)L"generic"};
             typedef BOOL (WINAPI *setwaitabletimerex_t)(HANDLE, const LARGE_INTEGER *, LONG, PTIMERAPCROUTINE, LPVOID, PREASON_CONTEXT, ULONG);
             static inline BOOL WINAPI SetWaitableTimerEx_emulation(HANDLE hTimer, const LARGE_INTEGER *lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, PREASON_CONTEXT WakeContext, ULONG TolerableDelay)
             {
@@ -719,8 +715,7 @@ namespace boost
                     if(time_left.milliseconds/20>tolerable)  // 5%
                         tolerable=time_left.milliseconds/20;
                     LARGE_INTEGER due_time=get_due_time(target_time);
-                    //bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,&detail_::default_reason_context,tolerable)!=0;
-                    bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,NULL,tolerable)!=0;
+                    bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,&detail_::default_reason_context,tolerable)!=0;
                     if(set_time_succeeded)
                     {
                         timeout_index=handle_count;
@@ -804,8 +799,7 @@ namespace boost
                     if(time_left.milliseconds/20>tolerable)  // 5%
                         tolerable=time_left.milliseconds/20;
                     LARGE_INTEGER due_time=get_due_time(target_time);
-                    //bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,&detail_::default_reason_context,tolerable)!=0;
-                    bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,NULL,tolerable)!=0;
+                    bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,&detail_::default_reason_context,tolerable)!=0;
                     if(set_time_succeeded)
                     {
                         timeout_index=handle_count;

test/Jamfile.v2

@@ -31,8 +31,7 @@ project
         <toolset>gcc:<cxxflags>-Wno-long-long
         #<toolset>gcc:<cxxflags>-ansi
         #<toolset>gcc:<cxxflags>-fpermissive
-        <toolset>gcc-4:<cxxflags>-Wno-variadic-macros
-        <toolset>gcc-5:<cxxflags>-Wno-variadic-macros
+        <toolset>gcc:<cxxflags>-Wno-variadic-macros
         #<toolset>gcc:<cxxflags>-Wunused-local-typedefs
         <toolset>gcc:<cxxflags>-Wunused-function
         <toolset>gcc:<cxxflags>-Wno-unused-parameter
@@ -811,8 +810,11 @@ rule thread-compile ( sources : reqs * : name )
           [ thread-run2 ../example/user_scheduler.cpp : ex_user_scheduler ]
           [ thread-run2 ../example/executor.cpp : ex_executor ]
           [ thread-run2 ../example/generic_executor_ref.cpp : ex_generic_executor_ref ]
+          [ thread-run2 ../example/generic_executor.cpp : ex_generic_executor ]
+          [ thread-run2 ../example/generic_serial_executor.cpp : ex_generic_serial_executor ]
           [ thread-run2 ../example/serial_executor.cpp : ex_serial_executor ]
-          #[ thread-run2 ../example/serial_executor_cont.cpp : ex_serial_executor_cont ]
+          [ thread-run2 ../example/generic_serial_executor_cont.cpp : ex_generic_serial_executor_cont ]
+          [ thread-run2 ../example/serial_executor_cont.cpp : ex_serial_executor_cont ]
           [ thread-run2 ../example/future_when_all.cpp : ex_future_when_all ]
           [ thread-run2 ../example/parallel_accumulate.cpp : ex_parallel_accumulate ]
           [ thread-run2 ../example/parallel_quick_sort.cpp : ex_parallel_quick_sort ]
@@ -959,13 +961,7 @@ rule thread-compile ( sources : reqs * : name )
     explicit ts_ ;
     test-suite ts_
     :
-          #[ thread-run test_11256.cpp ] 
           #[ thread-run test_11256.cpp ]
-          #[ thread-run test_11499.cpp ]
-          #[ thread-run test_11611.cpp ]
-          #[ thread-run test_11818.cpp ]
-          [ thread-run test_11796.cpp ]
-          
     ;
 
 

test/sync/futures/future/then_executor_pass.cpp

@@ -117,14 +117,6 @@ int main()
     BOOST_TEST(f2.get()==4);
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
-  {
-    boost::basic_thread_pool ex(1);
-    boost::future<int> f1 = boost::async(p1);
-    boost::future<int> f21 = f1.then(ex, &p2);
-    boost::future<int> f2= f21.then(&p2);
-    BOOST_TEST(f2.get()==4);
-  }
-  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
   {
     boost::basic_thread_pool ex(1);
     boost::future<int> f1 = boost::async(p1);

test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp

@@ -54,7 +54,7 @@ int main()
     BOOST_TEST(i == 1);
 
   }
-  catch(std::exception& )
+  catch(std::exception& ex)
   {
     BOOST_TEST(false);
   }

test/sync/futures/shared_future/then_executor_pass.cpp

@@ -104,14 +104,6 @@ int main()
     BOOST_TEST(f2.get()==2);
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
-  {
-    boost::basic_thread_pool ex(1);
-    boost::shared_future<int> f1 = boost::async(p1).share();
-    boost::shared_future<int> f21 = f1.then(ex, &p2).share();
-    boost::future<int> f2= f21.then(ex, &p2);
-    BOOST_TEST(f2.get()==4);
-  }
-  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
   {
     boost::basic_thread_pool ex(1);
     boost::shared_future<int> f1 = boost::async(p1).share();

test/sync/mutual_exclusion/deque_views/single_thread_pass.cpp

@@ -185,7 +185,7 @@ int main()
     // empty queue try_push lvalue succeeds
     boost::deque_adaptor<boost::sync_deque<int> > sq;
     boost::deque_back<int> q(sq);
-      int i=0;
+      int i;
       BOOST_TEST(boost::queue_op_status::success == q.try_push(i));
       BOOST_TEST(! q.empty());
       BOOST_TEST(! q.full());

test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_try_to_lock_pass.cpp

@@ -74,7 +74,7 @@ void f()
   }
   {
     time_point t0 = Clock::now();
-    for (;;)
+    while (true)
     {
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
       auto

test/sync/mutual_exclusion/queue_views/single_thread_pass.cpp

@@ -185,7 +185,7 @@ int main()
     // empty queue try_push lvalue succeeds
     boost::queue_adaptor<boost::sync_queue<int> > sq;
     boost::queue_back<int> q(sq);
-      int i=0;
+      int i;
       BOOST_TEST(boost::queue_op_status::success == q.try_push(i));
       BOOST_TEST(! q.empty());
       BOOST_TEST(! q.full());

test/sync/mutual_exclusion/sync_pq/pq_multi_thread_pass.cpp

@@ -105,7 +105,7 @@ void atomic_pull(sync_pq* q, boost::atomic<int>* sum)
             const int val = q->pull();
             sum->fetch_add(val);
         }
-        catch(std::exception&  ){
+        catch(std::exception& e ){
             break;
         }
     }
@@ -147,7 +147,7 @@ void move_between_queues(sync_pq* q1, sync_pq* q2)
             const int val = q1->pull();
             q2->push(val);
         }
-        catch(std::exception& ){
+        catch(std::exception& e){
             break;
         }
     }

test/test_10964.cpp

@@ -38,27 +38,6 @@ struct TestCallback
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     //boost::future<void> ff = future.get();
 
-    return boost::make_ready_future();
-  }
-  result_type operator()(boost::shared_future<void> future) const
-  {
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    assert(future.is_ready());
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    future.wait();
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    return boost::make_ready_future();
-  }
-
-  result_type operator()(boost::shared_future<boost::future<void> > future) const
-  {
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    assert(future.is_ready());
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    assert(future.get().is_ready());
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    //boost::future<void> ff = future.get();
-
     return boost::make_ready_future();
   }
 };
@@ -70,7 +49,6 @@ void p1()
 int main()
 {
   const int number_of_tests = 2;
-  (void)(number_of_tests);
 
 #if ! defined  BOOST_NO_CXX11_DECLTYPE && ! defined  BOOST_NO_CXX11_AUTO_DECLARATIONS
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
@@ -96,17 +74,11 @@ int main()
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   for (int i=0; i< number_of_tests; i++)
   {
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     auto f1 = boost::make_ready_future().then(TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
     boost::future<void> f2 = f1.get();
-  }
-  std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-  {
-    auto f1 = boost::make_ready_future().then(TestCallback());
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
-    auto f3 = f1.then(TestCallback());
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
-    f3.wait();
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   for (int i=0; i< number_of_tests; i++)
@@ -141,6 +113,8 @@ int main()
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
+
+
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   for (int i=0; i< number_of_tests; i++)
   {
@@ -151,12 +125,10 @@ int main()
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
-#if 1
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-  // fixme
   for (int i=0; i< number_of_tests; i++)
   {
-    boost::basic_thread_pool executor(2);
+    boost::basic_thread_pool executor(1);
 
     auto f1 = boost::make_ready_future().then(executor, TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
@@ -169,7 +141,6 @@ int main()
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
-#endif
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   for (int i=0; i< number_of_tests; i++)
   {

test/test_11499.cpp

@@ -1,56 +0,0 @@
-// Copyright (C) 2014 Vicente Botet
-//
-//  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)
-
-#define BOOST_THREAD_VERSION 4
-
-#include <boost/thread/shared_mutex.hpp>
-#include <thread>
-#include <mutex>
-#include <shared_mutex>
-#include <atomic>
-#include <vector>
-
-using MutexT = boost::shared_mutex;
-using ReaderLockT = std::lock_guard<MutexT>;
-using WriterLockT = std::shared_lock<MutexT>;
-
-MutexT gMutex;
-std::atomic<bool> running(true);
-
-
-void myread()
-{
-  long reads = 0;
-   while (running && reads < 100000)
-   {
-      ReaderLockT lock(gMutex);
-      std::this_thread::yield();
-      ++reads;
-   }
-}
-
-int main()
-{
-   using namespace std;
-
-   vector<thread> threads;
-   for (int i = 0; i < 256; ++i)
-   {
-      threads.emplace_back(thread(myread));
-   }
-
-//   string str;
-//
-//   getline(std::cin, str);
-   running = false;
-
-   for (auto& thread : threads)
-   {
-      thread.join();
-   }
-
-   return 0;
-}
-

test/test_11611.cpp

@@ -1,48 +0,0 @@
-// Copyright (C) 2014 Vicente Botet
-//
-//  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)
-
-//#define BOOST_THREAD_VERSION 4
-
-#include <iostream>
-//#include <thread>
-
-#define BOOST_THREAD_PROVIDES_FUTURE
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-#define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
-#include <boost/thread/executors/loop_executor.hpp>
-#include <boost/thread/executors/serial_executor_cont.hpp>
-#include <boost/thread/executors/serial_executor.hpp>
-#include <boost/thread/thread.hpp>
-
-using namespace std;
-
-int main()
-{
-   boost::loop_executor ex;
-
-   //thread t([&ex]()
-   boost::thread t([&ex]()
-   {
-      ex.loop();
-   });
-
-   {
-     //boost::serial_executor_cont serial(ex);
-     boost::serial_executor serial(ex);
-
-      for (size_t i = 0; i < 100000; i++)
-         serial.submit([i] {
-             //std::cout << i << ".";
-         });
-
-      serial.close();
-   }
-
-   ex.close();
-
-   t.join();
-   std::cout << "end" << std::endl;
-   return 0;
-}

test/test_11796.cpp

@@ -1,33 +0,0 @@
-// Copyright (C) 2015 Vicente Botet
-//
-//  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 <boost/thread.hpp>
-#include <boost/chrono.hpp>
-#include <iostream>
-
-boost::thread th;
-int main()
-{
-
-  for (auto ti = 0; ti < 1000; ti++)
-  {
-    th  = boost::thread([ti]()
-      {
-        boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
-        std::cout << ti << std::endl;
-      });
-  }
-  std::string st;
-
-  std::cin >> st;
-
-//  for (int i = 0; i < 10; ++i) {
-//    std::cout << "." << i << std::endl;
-//    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
-//  }
-  th.join();
-  return 0;
-}
-

test/test_11818.cpp

@@ -1,64 +0,0 @@
-// Copyright (C) 2014 Vicente Botet
-//
-//  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)
-
-#define BOOST_THREAD_VERSION 4
-#include <boost/config.hpp>
-#if ! defined  BOOST_NO_CXX11_DECLTYPE
-#define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
-
-#include <boost/thread/future.hpp>
-#include <boost/thread/thread.hpp>
-#include <thread>
-
-int main()
-{
-
-  {
-    boost::promise<int> promise;
-    boost::future<int> future = promise.get_future();
-
-    boost::future<int> result =
-    future.then
-    (
-        boost::launch::deferred,
-        [](boost::future<int> && f)
-        {
-            std::cout << std::this_thread::get_id() << ": callback" << std::endl;
-            std::cout << "The value is: " << f.get() << std::endl;
-            return f.get();
-        }
-    );
-
-    // We could not reach here.
-    std::cout << std::this_thread::get_id() << ": function" << std::endl;
-
-    promise.set_value(0);
-  }
-
-  {
-    boost::promise<int> promise;
-    boost::shared_future<int> future = promise.get_future().share();
-
-    boost::future<int> result =
-    future.then
-    (
-        boost::launch::deferred,
-        [](boost::shared_future<int> && f)
-        {
-            std::cout << std::this_thread::get_id() << ": callback" << std::endl;
-            std::cout << "The value is: " << f.get() << std::endl;
-            return f.get();
-        }
-    );
-
-    // We could not reach here.
-    std::cout << std::this_thread::get_id() << ": function" << std::endl;
-
-    promise.set_value(0);
-  }
-
-  return 0;
-}

test/test_2309.cpp

@@ -5,13 +5,12 @@
 
 #define BOOST_THREAD_VERSION 2
 #define BOOST_THREAD_PROVIDES_INTERRUPTIONS
-//#define BOOST_TEST_MODULE Boost.Threads: 2309
-//#include <boost/test/unit_test.hpp>
+#define BOOST_TEST_MODULE Boost.Threads: 2309
+#include <boost/test/unit_test.hpp>
 
 #include <iostream>
 
 #include <boost/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
 
   using namespace std;
 
@@ -41,7 +40,7 @@
      }
   }
 
-  void ticket_2309_test()
+  BOOST_AUTO_TEST_CASE(test)
   {
     try
     {
@@ -58,13 +57,9 @@
     }
     catch (...)
     {
-      BOOST_TEST(false && "exception raised");
+      BOOST_CHECK(false && "exception raised");
     }
   }
 
-  int main()
-  {
 
-    ticket_2309_test();
-  }
 

test/test_2741.cpp

@@ -35,7 +35,6 @@ BOOST_AUTO_TEST_CASE(test_native_handle)
   boost::thread_attributes attrs;
 
   boost::thread_attributes::native_handle_type* h = attrs.native_handle();
-  (void)(h); // unused
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
   // ... window version
 #elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
@@ -76,4 +75,3 @@ BOOST_AUTO_TEST_CASE(test_creation_with_attrs)
   timed_test(&do_test_creation_with_attrs, 1);
 }
 
-

test/test_4648.cpp

@@ -30,7 +30,7 @@ int boostThreadLocksTest::firstFunction(boostThreadLocksTest *pBoostThreadLocksT
   std::cout<<"Returning from "<<boost::this_thread::get_id()<<" "<<"firstFunction"<<std::endl;
   return(0);
 }
-int boostThreadLocksTest::secondFunction(boostThreadLocksTest *, boost::upgrade_lock<boost::shared_mutex>& upgr) {
+int boostThreadLocksTest::secondFunction(boostThreadLocksTest */*pBoostThreadLocksTest*/, boost::upgrade_lock<boost::shared_mutex>& upgr) {
   std::cout<<"Before Exclusive Locking "<<boost::this_thread::get_id()<<" "<<"secondFunction"<<std::endl;
   boost::upgrade_to_unique_lock<boost::shared_mutex> localUniqueLock(upgr);
   std::cout<<"After Exclusive Locking "<<boost::this_thread::get_id()<<" "<<"secondFunction"<<std::endl;

test/test_4882.cpp

@@ -45,7 +45,7 @@ void thread()
 #endif
     }
   }
-  BOOST_CATCH (boost::lock_error& )
+  BOOST_CATCH (boost::lock_error& le)
   {
     //BOOST_THREAD_LOG << "lock_error exception thrd>" << BOOST_THREAD_END_LOG;
   }

test/test_scheduled_tp.cpp

@@ -24,7 +24,7 @@
 
 using namespace boost::chrono;
 
-typedef boost::scheduled_thread_pool scheduled_tp;
+typedef boost::scheduled_thread_pool<> scheduled_tp;
 
 void fn(int x)
 {
@@ -46,19 +46,18 @@ void func2(scheduled_tp* tp, steady_clock::duration d)
 void test_timing(const int n)
 {
   //This function should take n seconds to execute.
-  boost::scheduled_thread_pool se(4);
+  boost::scheduled_thread_pool<> se(4);
 
   for(int i = 1; i <= n; i++)
   {
     se.submit_after(boost::bind(fn,i), milliseconds(i*100));
   }
-  boost::this_thread::sleep_for(boost::chrono::seconds(10));
   //dtor is called here so all task will have to be executed before we return
 }
 
 void test_deque_timing()
 {
-    boost::scheduled_thread_pool se(4);
+    boost::scheduled_thread_pool<> se(4);
     for(int i = 0; i < 10; i++)
     {
         steady_clock::duration d = milliseconds(i*100);
@@ -85,10 +84,10 @@ void test_deque_multi(const int n)
 
 int main()
 {
-  steady_clock::time_point start = steady_clock::now();
+  //steady_clock::time_point start = steady_clock::now();
   test_timing(5);
-  steady_clock::duration diff = steady_clock::now() - start;
-  BOOST_TEST(diff > milliseconds(500));
+  //steady_clock::duration diff = steady_clock::now() - start;
+  //BOOST_TEST(diff > milliseconds(500));
   test_deque_timing();
   test_deque_multi(4);
   test_deque_multi(8);

test/test_scheduler.cpp

@@ -27,7 +27,6 @@ typedef boost::executors::basic_thread_pool thread_pool;
 
 void fn(int x)
 {
-  //std::cout << "[" << __LINE__ << "] " << steady_clock::now() << std::endl;
     std::cout << x << std::endl;
 }
 
@@ -75,7 +74,7 @@ int main()
   test_after(5, sch);
   test_at(5, sch);
   test_on(5, sch, tp);
-  boost::this_thread::sleep_for(boost::chrono::seconds(10));
+  std::cout << "[" << __LINE__ << "] " << std::endl;
 
   return boost::report_errors();
 }

test/test_scheduling_adaptor.cpp

@@ -28,7 +28,6 @@ typedef boost::executors::basic_thread_pool thread_pool;
 
 void fn(int x)
 {
-  //std::cout << "[" << __LINE__ << "] " << steady_clock::now() << std::endl;
     std::cout << x << std::endl;
 }
 
@@ -41,14 +40,10 @@ void test_timing(const int n)
         sa.submit_after(boost::bind(fn,i),seconds(i));
         sa.submit_after(boost::bind(fn,i), milliseconds(i*100));
     }
-    boost::this_thread::sleep_for(boost::chrono::seconds(10));
 }
 
 int main()
 {
-  steady_clock::time_point start = steady_clock::now();
   test_timing(5);
-  steady_clock::duration diff = steady_clock::now() - start;
-  BOOST_TEST(diff > seconds(5));
   return boost::report_errors();
 }

test/threads/this_thread/sleep_until/sleep_until_pass.cpp

@@ -28,7 +28,7 @@ int main()
   {
     typedef boost::chrono::steady_clock Clock;
     typedef Clock::time_point time_point;
-    //typedef Clock::duration duration;
+    typedef Clock::duration duration;
     boost::chrono::milliseconds ms(500);
     time_point t0 = Clock::now();
     boost::this_thread::sleep_until(t0 + ms);
@@ -43,7 +43,7 @@ int main()
   {
     typedef boost::chrono::system_clock Clock;
     typedef Clock::time_point time_point;
-    //typedef Clock::duration duration;
+    typedef Clock::duration duration;
     boost::chrono::milliseconds ms(500);
     time_point t0 = Clock::now();
     boost::this_thread::sleep_until(t0 + ms);
@@ -58,7 +58,7 @@ int main()
   {
     typedef boost::chrono::steady_clock Clock;
     typedef Clock::time_point time_point;
-    //typedef Clock::duration duration;
+    typedef Clock::duration duration;
     boost::chrono::milliseconds ms(500);
     time_point t0 = Clock::now();
     boost::this_thread::no_interruption_point::sleep_until(t0 + ms);
@@ -73,7 +73,7 @@ int main()
   {
     typedef boost::chrono::system_clock Clock;
     typedef Clock::time_point time_point;
-    //typedef Clock::duration duration;
+    typedef Clock::duration duration;
     boost::chrono::milliseconds ms(500);
     time_point t0 = Clock::now();
     boost::this_thread::no_interruption_point::sleep_until(t0 + ms);