Merge branch 'develop'

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

@@ -1,5 +1,5 @@
 [/
- / Copyright (c) 2014-2015 Vicente J. Botet Escriba
+ / Copyright (c) 2014 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)
@@ -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 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.
+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.
 
 [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,6 +506,9 @@ Executor abstract base class.
     public:
       typedef  boost::work work;
   
+      executor(executor const&) = delete;
+      executor& operator=(executor const&) = delete;
+
       executor(); 
       virtual ~executor() {};
   
@@ -570,6 +573,9 @@ 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);
 
@@ -635,24 +641,20 @@ Polymorphic adaptor of a model of Executor to an executor.
 [/////////////////////////////////]
 [section:generic_executor_ref Class `generic_executor_ref`]
 
-Type erased executor class.
+Executor abstract base 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() = 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;
+      generic_executor_ref() {};
   
-      executor& underlying_executor() noexcept;
-
       void close() = 0;
       bool closed() = 0;
   
@@ -667,44 +669,6 @@ Type erased executor 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 `]
 
@@ -719,7 +683,10 @@ 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();
  
@@ -766,7 +733,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 destructor.]]
+[[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
 
 ]
 
@@ -847,7 +814,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);
 
@@ -1372,6 +1339,10 @@ 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;
@@ -1422,7 +1393,7 @@ A serial executor ensuring that there are no two work units that executes concur
 [/////////////////////////////////////]
 [section:underlying_executor Function member `underlying_executor()`]
 
-      Executor& underlying_executor() noexcept;
+      generic_executor_ref& underlying_executor() noexcept;
 
 [variablelist
 
@@ -1447,10 +1418,13 @@ 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& underlying_executor() noexcept;
+      generic_executor_ref& underlying_executor() noexcept;
 
       void close();
       bool closed();
@@ -1459,7 +1433,6 @@ 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);
 
@@ -1483,7 +1456,7 @@ A serial executor ensuring that there are no two work units that executes concur
 
 [endsect]
 [/////////////////////////////////////]
-[section:destructor Destructor `~generic_serial_executor()`]
+[section:destructor Destructor `~serial_executor()`]
 
       ~generic_serial_executor();
 
@@ -1495,80 +1468,6 @@ 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()`]
@@ -1579,8 +1478,6 @@ A serial executor ensuring that there are no two work units that executes concur
 
 [[Return:] [The underlying executor instance. ]]
 
-[[Throws:] [Nothing.]]
-
 ]
 
 
@@ -1588,82 +1485,6 @@ 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`]
@@ -1675,8 +1496,10 @@ 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();
@@ -1737,6 +1560,9 @@ 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>
@@ -1797,6 +1623,9 @@ 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);
@@ -1851,6 +1680,9 @@ 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,51 +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/11424 #11424] Provide shared_timed_mutex as an alternative name for shared_mutex and deprecate the use of shared_mutex as a timed mutex
-
-[*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/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/11158 #11158] Pthread thread deadlock when faketime used
-* [@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/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/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] Timer (using steady_clock) 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
-
-
 [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).
@@ -345,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
@@ -885,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
@@ -898,7 +897,7 @@ 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.]]
 
@@ -908,10 +907,10 @@ All the functions create a shared state that is associated with the returned fut
 
 - The continuation is called when the object's shared state is ready (has a value or exception stored).
 
-- The continuation launches according to the specified policy or executor.
+- The continuation launches according to the specified policy or scheduler.
 
-- When the executor or launch policy is not provided the continuation inherits the
-parent's launch policy or executor.
+- When the scheduler or launch policy is not provided the continuation inherits the
+parent's launch 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`. 
 
@@ -1362,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
@@ -1376,7 +1375,7 @@ 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.]]
 
@@ -1384,17 +1383,17 @@ second parameter.]]
 
 - The continuation is called when the object's shared state is ready (has a value or exception stored).
 
-- The continuation launches according to the specified policy or executor.
+- The continuation launches according to the specified policy or scheduler.
 
-- When the executor or launch policy is not provided the continuation inherits the
-parent's launch policy or executor.
+- 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.
 
 - If the parent has a policy of `launch::deferred` and the continuation does not have a specified launch policy or 
-executor, then the parent is filled by immediately calling `.wait()`, and the policy of the antecedent is 
+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).
@@ -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 a 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_tutorial.qbk

@@ -7,9 +7,7 @@
 
 [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://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.
 

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/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>
@@ -28,10 +27,8 @@
 #include <boost/assert.hpp>
 #include <string>
 #include <iostream>
-#include <cassert>
 
-boost::future<void> p(boost::future<void> f) {
-    assert(f.is_ready());
+boost::future<void> p(boost::future<void>) {
     return boost::make_ready_future();
 }
 
@@ -49,9 +46,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,154 +69,68 @@ 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
     {
-//      {
-//        std::cout << BOOST_CONTEXTOF << std::endl;
-//        boost::basic_thread_pool e1;
-//        std::cout << BOOST_CONTEXTOF << std::endl;
-//        boost::basic_thread_pool e2 = e1;
-//        std::cout << BOOST_CONTEXTOF << std::endl;
-//      }
       {
-        std::cout << BOOST_CONTEXTOF << std::endl;
         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
-      {
-        std::cout << BOOST_CONTEXTOF << std::endl;
-        boost::executor_adaptor < boost::basic_thread_pool > ea(4);
-      // 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 << std::endl;
+        {
+          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);
-//        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 << std::endl;
+        {
+          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;
-      }
-#endif
-      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();
       }
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         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;
       {
-        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);
+        boost::executor_adaptor < boost::basic_thread_pool > ea1(4);
+        boost::executor_adaptor < boost::serial_executor > ea2(ea1);
         submit_some(ea2);
       }
-//#endif
+#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);
-      }
       {
         boost::executor_adaptor < boost::inline_executor > ea1;
         submit_some(ea1);
       }
-      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);
-      }
-
+      // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::executor_adaptor < boost::thread_executor > ea1;
         submit_some(ea1);
       }
-      std::cout << BOOST_CONTEXTOF << std::endl;
-#if 0
-      // 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 0
-      // 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)
     {
@@ -242,17 +152,14 @@ 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
 
-  boost::basic_thread_pool executor;
   // compiles
   boost::make_ready_future().then(&p);
 
-  // ??
-  boost::make_ready_future().then(executor, &p);
-
+  boost::basic_thread_pool executor;
   // doesn't compile
   boost::make_ready_future().then(executor, &p);
 #endif

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

@@ -1,184 +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)
-
-#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,12 +17,11 @@
 #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_ref.hpp>
 #include <boost/thread/executor.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/assert.hpp>
@@ -65,7 +64,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& )
 {
 
 }
@@ -74,71 +73,61 @@ 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
     {
       {
         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;
-//        }
+        {
+          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;
+      // 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::generic_serial_executor ea2(ea1);
+        boost::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;
-//      {
-//        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 << 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;
-
+      // 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)
     {

example/generic_serial_executor.cpp

@@ -1,117 +0,0 @@
-// 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

@@ -1,124 +0,0 @@
-// 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;
-     std::cout << BOOST_CONTEXTOF << std::endl;
-     boost::generic_serial_executor_cont e1(tp);
-     std::cout << BOOST_CONTEXTOF << std::endl;
-     boost::generic_serial_executor_cont e2 = e1;
-     std::cout << BOOST_CONTEXTOF << std::endl;
-  }
-   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);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-        boost::generic_serial_executor_cont ea2(ea1);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-        submit_some(ea2);
-        std::cout << BOOST_CONTEXTOF << std::endl;
-      }
-#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/make_future.cpp

@@ -94,11 +94,6 @@ int main()
     f.get();
   }
 #endif
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    boost::future<int> f = compute(-1);
-    f.wait();
-  }
   {
     std::cout << __FILE__ << " "<< __LINE__ << std::endl;
     boost::future<int> f = compute(0);
@@ -129,11 +124,11 @@ int main()
     boost::future<int const&> f = boost::make_ready_future(boost::cref(i));
     std::cout << f.get() << std::endl;
   }
-  {
-    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    boost::future<int> f = compute(2);
-    std::cout << f.get() << std::endl;
-  }
+//  {
+//    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
+//    boost::future<int> f = compute(2);
+//    std::cout << f.get() << std::endl;
+//  }
   {
     std::cout << __FILE__ << " "<< __LINE__ << std::endl;
     boost::shared_future<int> f = shared_compute(0);

example/producer_consumer.cpp

@@ -24,7 +24,7 @@
 #endif
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
 
-void producer(the_ostream & /*mos*/, boost::sync_queue<int> & sbq)
+void producer(the_ostream &mos, boost::sync_queue<int> & sbq)
 {
   using namespace boost;
   try {
@@ -32,22 +32,22 @@ void producer(the_ostream & /*mos*/, boost::sync_queue<int> & sbq)
     {
       sbq.push(i);
       //sbq << i;
-      //mos << "push(" << i << ") "<< sbq.size()<<"\n";
+      mos << "push(" << i << ") "<< sbq.size()<<"\n";
       this_thread::sleep_for(chrono::milliseconds(200));
     }
   }
   catch(sync_queue_is_closed&)
   {
-    //mos << "closed !!!\n";
+    mos << "closed !!!\n";
   }
   catch(...)
   {
-    //mos << "exception !!!\n";
+    mos << "exception !!!\n";
   }
 }
 
 void consumer(
-    the_ostream & /*mos*/,
+    the_ostream &mos,
     boost::sync_queue<int> & sbq)
 {
   using namespace boost;
@@ -57,21 +57,21 @@ void consumer(
       int r;
       sbq.pull(r);
       //sbq >> r;
-      //mos << i << " pull(" << r << ") "<< sbq.size()<<"\n";
+      mos << i << " pull(" << r << ") "<< sbq.size()<<"\n";
 
       this_thread::sleep_for(chrono::milliseconds(250));
     }
   }
   catch(sync_queue_is_closed&)
   {
-    //mos << "closed !!!\n";
+    mos << "closed !!!\n";
   }
   catch(...)
   {
-    //mos << "exception !!!\n";
+    mos << "exception !!!\n";
   }
 }
-void consumer2(the_ostream &/*mos*/, boost::sync_queue<int> & sbq)
+void consumer2(the_ostream &mos, boost::sync_queue<int> & sbq)
 {
   using namespace boost;
   try {
@@ -81,17 +81,17 @@ void consumer2(the_ostream &/*mos*/, boost::sync_queue<int> & sbq)
       queue_op_status st = sbq.try_pull(r);
       if (queue_op_status::closed == st) break;
       if (queue_op_status::success == st) {
-        //mos << i << " pull(" << r << ")\n";
+        mos << i << " pull(" << r << ")\n";
       }
       this_thread::sleep_for(chrono::milliseconds(250));
     }
   }
   catch(...)
   {
-    //mos << "exception !!!\n";
+    mos << "exception !!!\n";
   }
 }
-void consumer3(the_ostream &/*mos*/, boost::sync_queue<int> & sbq)
+void consumer3(the_ostream &mos, boost::sync_queue<int> & sbq)
 {
   using namespace boost;
   try {
@@ -100,13 +100,13 @@ void consumer3(the_ostream &/*mos*/, boost::sync_queue<int> & sbq)
       int r;
       queue_op_status res = sbq.wait_pull(r);
       if (res==queue_op_status::closed) break;
-      //mos << i << " wait_pull(" << r << ")\n";
+      mos << i << " wait_pull(" << r << ")\n";
       this_thread::sleep_for(chrono::milliseconds(250));
     }
   }
   catch(...)
   {
-    //mos << "exception !!!\n";
+    mos << "exception !!!\n";
   }
 }
 

example/producer_consumer2.cpp

@@ -27,7 +27,7 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
 
-void producer(the_ostream &/*mos*/, boost::queue_back<int> sbq)
+void producer(the_ostream &mos, boost::queue_back<int> sbq)
 {
   using namespace boost;
   try {
@@ -35,22 +35,22 @@ void producer(the_ostream &/*mos*/, boost::queue_back<int> sbq)
     {
       sbq.push(i);
       //sbq << i;
-      //mos << "push(" << i << ") " << sbq.size() <<"\n";
+      mos << "push(" << i << ") " << sbq.size() <<"\n";
       this_thread::sleep_for(chrono::milliseconds(200));
     }
   }
   catch(sync_queue_is_closed&)
   {
-    //mos << "closed !!!\n";
+    mos << "closed !!!\n";
   }
   catch(...)
   {
-    //mos << "exception !!!\n";
+    mos << "exception !!!\n";
   }
 }
 
 void consumer(
-    the_ostream &/*mos*/,
+    the_ostream &mos,
     boost::queue_front<int> sbq)
 {
   using namespace boost;
@@ -60,21 +60,21 @@ void consumer(
       int r;
       sbq.pull(r);
       //sbq >> r;
-      //mos << i << " pull(" << r << ") " << sbq.size()  <<"\n";
+      mos << i << " pull(" << r << ") " << sbq.size()  <<"\n";
 
       this_thread::sleep_for(chrono::milliseconds(250));
     }
   }
   catch(sync_queue_is_closed&)
   {
-    //mos << "closed !!!\n";
+    mos << "closed !!!\n";
   }
   catch(...)
   {
-    //mos << "exception !!!\n";
+    mos << "exception !!!\n";
   }
 }
-void consumer2(the_ostream &/*mos*/, boost::queue_front<int> sbq)
+void consumer2(the_ostream &mos, boost::queue_front<int> sbq)
 {
   using namespace boost;
   try {
@@ -84,17 +84,17 @@ void consumer2(the_ostream &/*mos*/, boost::queue_front<int> sbq)
       queue_op_status st = sbq.try_pull(r);
       if (queue_op_status::closed == st) break;
       if (queue_op_status::success == st) {
-        //mos << i << " try_pull(" << r << ")\n";
+        mos << i << " try_pull(" << r << ")\n";
       }
       this_thread::sleep_for(chrono::milliseconds(250));
     }
   }
   catch(...)
   {
-    //mos << "exception !!!\n";
+    mos << "exception !!!\n";
   }
 }
-void consumer3(the_ostream &/*mos*/, boost::queue_front<int> sbq)
+void consumer3(the_ostream &mos, boost::queue_front<int> sbq)
 {
   using namespace boost;
   try {
@@ -103,13 +103,13 @@ void consumer3(the_ostream &/*mos*/, boost::queue_front<int> sbq)
       int r;
       queue_op_status res = sbq.wait_pull(r);
       if (res==queue_op_status::closed) break;
-      //mos << i << " wait_pull(" << r << ")\n";
+      mos << i << " wait_pull(" << r << ")\n";
       this_thread::sleep_for(chrono::milliseconds(250));
     }
   }
   catch(...)
   {
-    //mos << "exception !!!\n";
+    mos << "exception !!!\n";
   }
 }
 

example/recursive_mutex.cpp

@@ -32,7 +32,7 @@ counter c;
 
 void change_count()
 {
-    //std::cout << "count == " << c.increment() << std::endl;
+    std::cout << "count == " << c.increment() << std::endl;
 }
 
 int main(int, char*[])

example/serial_executor.cpp

@@ -27,16 +27,16 @@
 
 void p1()
 {
-  //std::cout << BOOST_CONTEXTOF << std::endl;
+  std::cout << BOOST_CONTEXTOF << std::endl;
   boost::this_thread::sleep_for(boost::chrono::milliseconds(30));
-  //std::cout << BOOST_CONTEXTOF << std::endl;
+  std::cout << BOOST_CONTEXTOF << std::endl;
 }
 
 void p2()
 {
-  //std::cout << BOOST_CONTEXTOF << std::endl;
+  std::cout << BOOST_CONTEXTOF << std::endl;
   boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
-  //std::cout << BOOST_CONTEXTOF << std::endl;
+  std::cout << BOOST_CONTEXTOF << std::endl;
 }
 
 int f1()
@@ -51,9 +51,10 @@ int f2(int i)
   boost::this_thread::sleep_for(boost::chrono::seconds(2));
   return i + 1;
 }
-template <class Executor>
-void submit_some(boost::serial_executor<Executor>& tp)
+
+void submit_some(boost::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);
@@ -62,6 +63,7 @@ void submit_some(boost::serial_executor<Executor>& tp)
     std::cout << BOOST_CONTEXTOF << std::endl;
     tp.submit(&p1);
   }
+  std::cout << BOOST_CONTEXTOF << std::endl;
 
 }
 
@@ -73,17 +75,21 @@ void at_th_entry(boost::basic_thread_pool& )
 
 int test_executor_adaptor()
 {
+  // 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::serial_executor<boost::basic_thread_pool> ea2(ea1);
+        boost::serial_executor ea2(ea1);
         submit_some(ea2);
+        boost::this_thread::sleep_for(boost::chrono::seconds(10));
       }
 #endif
+      // std::cout << BOOST_CONTEXTOF << std::endl;
     }
     catch (std::exception& ex)
     {
@@ -96,6 +102,7 @@ int test_executor_adaptor()
       return 2;
     }
   }
+  // std::cout << BOOST_CONTEXTOF << std::endl;
   return 0;
 }
 

example/serial_executor_cont.cpp

@@ -52,19 +52,18 @@ int f2(int i)
   return i + 1;
 }
 
-template < class Executor>
-void submit_some(boost::serial_executor_cont<Executor>& tp)
+void submit_some(boost::serial_executor_cont& 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;
 
 }
 
@@ -85,8 +84,9 @@ int test_executor_adaptor()
       // std::cout << BOOST_CONTEXTOF << std::endl;
       {
         boost::basic_thread_pool ea1(4);
-        boost::serial_executor_cont<boost::basic_thread_pool> ea2(ea1);
+        boost::serial_executor_cont 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/thread_group.cpp

@@ -59,7 +59,6 @@ int main()
     threads.remove_thread(th);
     BOOST_TEST(! threads.is_thread_in(th));
     th->join();
-    delete th;
   }
   {
     {

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/csbl/memory.hpp

@@ -57,6 +57,5 @@ namespace boost
 // 20.8.2.4, class template enable_shared_from_this:
 // 20.8.2.5, shared_ptr atomic access:
 // 20.8.2.6 hash support
-#include <boost/thread/csbl/memory/shared_ptr.hpp>
 
 #endif // header

include/boost/thread/csbl/memory/shared_ptr.hpp

@@ -11,30 +11,17 @@
 
 #include <boost/thread/csbl/memory/config.hpp>
 
-//#if defined BOOST_NO_CXX11_SMART_PTR
-#if 1
+#if defined BOOST_NO_CXX11_SMART_PTR
 
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
-#include <boost/enable_shared_from_this.hpp>
 
 namespace boost
 {
-  template<class T> bool atomic_compare_exchange_strong( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
-  {
-    return atomic_compare_exchange(p,v,w);
-  }
-
   namespace csbl
   {
     using ::boost::shared_ptr;
     using ::boost::make_shared;
-    using ::boost::static_pointer_cast;
-    using ::boost::dynamic_pointer_cast;
-    using ::boost::const_pointer_cast;
-    using ::boost::enable_shared_from_this;
-    using ::boost::atomic_load;
-    using ::boost::atomic_compare_exchange_strong;
   }
 }
 
@@ -48,12 +35,6 @@ namespace boost
   {
     using std::shared_ptr;
     using std::make_shared;
-    using std::dynamic_pointer_cast;
-    using std::static_pointer_cast;
-    using std::const_pointer_cast;
-    using std::enable_shared_from_this;
-    using std::atomic_load;
-    using std::atomic_compare_exchange_strong;
   }
 }
 

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

@@ -173,6 +173,7 @@ namespace boost
     private:
         bool start_thread_noexcept();
         bool start_thread_noexcept(const attributes& attr);
+    //public:
         void start_thread()
         {
           if (!start_thread_noexcept())
@@ -484,9 +485,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);
@@ -838,7 +839,7 @@ namespace boost
         void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
         struct shared_state_base;
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
-        inline void make_ready_at_thread_exit(csbl::shared_ptr<shared_state_base> as)
+        inline void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
         {
           detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
           if(current_thread_data)
@@ -847,7 +848,7 @@ namespace boost
           }
         }
 #else
-        void BOOST_THREAD_DECL make_ready_at_thread_exit(csbl::shared_ptr<shared_state_base> as);
+        void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as);
 #endif
     }
 

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-2015 Vicente J. Botet Escriba
+// Copyright (C) 2013-2014 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,16 +13,11 @@
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
-#include <boost/thread/thread.hpp>
+#include <boost/thread/scoped_thread.hpp>
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
 #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
@@ -35,267 +30,125 @@ namespace executors
     /// type-erasure to store the works to do
     typedef  executors::work work;
   private:
+    /// 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 csbl::vector<thread_t> thread_vector;
 
-    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;
+    /// the thread safe work queue
+    concurrent::sync_queue<work > work_queue;
+    /// A move aware vector
+    thread_vector threads;
 
-      /// 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;
-
-
-    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()
+  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
       {
-        try
+        work task;
+        if (work_queue.try_pull(task) == queue_op_status::success)
         {
-          work task;
-          if (work_queue.try_pull(task) == queue_op_status::success)
-          {
-            task();
-            return true;
-          }
-          return false;
+          task();
+          return true;
         }
-        catch (...)
+        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())
         {
-          std::terminate();
-          return false;
+          this_thread::yield();
         }
-      }
-      /**
-       * 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 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.
-       */
-
-      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)
-      {
-        //work_queue.push(work(closure));
-        submit(work(closure));
-
-      }
-  #endif
-      void submit(void (*closure)())
-      {
-        //work_queue.push(work(closure));
-        submit(work(closure));
-      }
-
-      template <typename Closure>
-      void submit(BOOST_THREAD_FWD_REF(Closure) closure)
-      {
-        //work_queue.push(work(boost::forward<Closure>(closure)));
-        work w((boost::forward<Closure>(closure)));
-        submit(boost::move(w));
-      }
-
-      /**
-       * \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;
-      }
-    };
+    }
+  private:
 
     /**
-     * \b Effects: creates a thread pool with this shared state.
-     *
-     * \b Throws: Whatever exception is thrown while initializing the needed resources.
+     * The main loop of the worker threads
      */
-    friend struct shared_state;
-    basic_thread_pool(shared_ptr<shared_state> ptr)
-    : pimpl(ptr)
+    void worker_thread()
     {
+      try
+      {
+        for(;;)
+        {
+          work task;
+          queue_op_status st = work_queue.wait_pull(task);
+          if (st == queue_op_status::closed) return;
+          task();
+        }
+      }
+      catch (...)
+      {
+        std::terminate();
+        return;
+      }
     }
+#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&) {}
+
   public:
-    //basic_thread_pool(basic_thread_pool const&)=default;
-    //basic_thread_pool(basic_thread_pool &&)=default;
+    /// 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))
     {
-      pimpl->init();
+      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;
+      }
     }
-
     /**
      * \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. .
@@ -305,24 +158,61 @@ 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))
     {
-      pimpl->init();
+      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;
+      }
     }
 #endif
-
-    basic_thread_pool( unsigned const thread_count, void(*at_thread_entry)(basic_thread_pool))
-    : pimpl(make_shared<shared_state>(thread_count, at_thread_entry))
+    basic_thread_pool( unsigned const thread_count, void(*at_thread_entry)(basic_thread_pool&))
     {
-      pimpl->init();
+      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;
+      }
     }
     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)))
     {
-      pimpl->init();
+      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;
+      }
     }
-
     /**
      * \b Effects: Destroys the thread pool.
      *
@@ -330,16 +220,9 @@ namespace executors
      */
     ~basic_thread_pool()
     {
-    }
-
-    /**
-     * 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();
+      // signal to all the worker threads that there will be no more submissions.
+      close();
+      // joins all the threads as the threads were scoped_threads
     }
 
     /**
@@ -347,7 +230,10 @@ namespace executors
      */
     void join()
     {
-      pimpl->join();
+      for (unsigned i = 0; i < threads.size(); ++i)
+      {
+        threads[i].join();
+      }
     }
 
     /**
@@ -356,7 +242,7 @@ namespace executors
      */
     void close()
     {
-      pimpl->close();
+      work_queue.close();
     }
 
     /**
@@ -364,7 +250,7 @@ namespace executors
      */
     bool closed()
     {
-      return pimpl->closed();
+      return work_queue.closed();
     }
 
     /**
@@ -378,26 +264,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)
     {
-      pimpl->submit(closure);
+      work_queue.push(work(closure));
     }
 #endif
     void submit(void (*closure)())
     {
-      pimpl->submit(closure);
+      work_queue.push(work(closure));
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      pimpl->submit(boost::forward<Closure>(closure));
+      work_queue.push(work(boost::forward<Closure>(closure)));
     }
 
     /**
@@ -408,16 +291,15 @@ namespace executors
     template <typename Pred>
     bool reschedule_until(Pred const& pred)
     {
-      return pimpl->reschedule_until(pred);
+      do {
+        if ( ! try_executing_one())
+        {
+          return false;
+        }
+      } while (! pred());
+      return true;
     }
 
-    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,6 +24,7 @@ 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,2015 Vicente J. Botet Escriba
+// Copyright (C) 2013,2014 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,6 +27,8 @@ namespace boost
     /// type-erasure to store the works to do
     typedef  executors::work work;
 
+    /// executor is not copyable.
+    BOOST_THREAD_NO_COPYABLE(executor)
     executor() {}
 
     /**
@@ -97,10 +99,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));
     }
 
@@ -127,6 +128,7 @@ 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,2015 Vicente J. Botet Escriba
+// Copyright (C) 2013,2014 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)
@@ -12,7 +12,6 @@
 #include <boost/thread/detail/config.hpp>
 
 #include <boost/thread/executors/executor.hpp>
-#include <boost/thread/detail/move.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -31,52 +30,21 @@ 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 constructor
      */
-    //executor_adaptor(executor_adaptor const&) = default;
-    //executor_adaptor(executor_adaptor &&) = default;
-    BOOST_THREAD_COPYABLE_AND_MOVABLE(executor_adaptor)
-
-    executor_adaptor(executor_adaptor const& x) : ex(x.ex) {}
-    executor_adaptor(BOOST_THREAD_RV_REF(executor_adaptor) x)  : ex(boost::move(x.ex)) {}
-
-    executor_adaptor& operator=(BOOST_THREAD_COPY_ASSIGN_REF(executor_adaptor) x)
-    {
-      if (this != &ex)
-      {
-        ex = x.ex;
-      }
-      return *this;
-    }
-    executor_adaptor& operator=(BOOST_THREAD_RV_REF(executor_adaptor) x)
-    {
-      if (this != &ex)
-      {
-        ex = boost::move(x.ex);
-      }
-      return *this;
-    }
-
-    executor_adaptor(Executor const& ex) : ex(ex) {}
-    executor_adaptor(BOOST_THREAD_RV_REF(Executor) ex)  : ex(boost::move(ex)) {}
-
-    executor_adaptor() : ex() {}
-
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <typename Arg, typename ...Args>
-    executor_adaptor(BOOST_THREAD_FWD_REF(Arg) arg, BOOST_THREAD_FWD_REF(Args) ... args
-        , typename disable_if_c<
-          is_same<typename decay<Arg>::type, executor_adaptor>::value
-            ||
-          is_same<typename decay<Arg>::type, Executor>::value
-    , int* >::type=0
-        )
-    : ex(boost::forward<Arg>(arg), boost::forward<Args>(args)...) {}
+    template <typename ...Args>
+    executor_adaptor(BOOST_THREAD_RV_REF(Args) ... args) : ex(boost::forward<Args>(args)...) {}
 #else
     /**
      * executor_adaptor constructor
      */
+    executor_adaptor() : ex() {}
+
     template <typename A1>
     executor_adaptor(
         BOOST_THREAD_FWD_REF(A1) a1
@@ -130,6 +98,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>
@@ -144,11 +115,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)));
     }
 
     /**
@@ -161,9 +130,6 @@ namespace executors
   };
 }
 using executors::executor_adaptor;
-
-BOOST_THREAD_DCL_MOVABLE_BEG(T) executor_adaptor<T> BOOST_THREAD_DCL_MOVABLE_END
-
 }
 
 #include <boost/config/abi_suffix.hpp>

include/boost/thread/executors/generic_executor.hpp

@@ -1,150 +0,0 @@
-// 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,8 +13,7 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/executors/executor.hpp>
 
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -100,8 +99,8 @@ namespace boost
 
     template<typename Executor>
     generic_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) )
+    //: ex(make_shared<executor_ref<Executor> >(ex)) // todo check why this doesn't works with C++03
+    : ex( new executor_ref<Executor>(ex) )
     {
     }
 
@@ -122,6 +121,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.
@@ -138,31 +142,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

@@ -1,295 +0,0 @@
-// 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 thread thread_t;
-      //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();
-        join();
-      }
-
-      /**
-       * \b Effects: join all the threads.
-       */
-      void join()
-      {
-          if (this_thread::get_id() == thr.get_id()) return;
-          thr.join();
-      }
-
-      /**
-       * \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

@@ -1,265 +0,0 @@
-// 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-2015 Vicente J. Botet Escriba
+// Copyright (C) 2014 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,9 +14,6 @@
 #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
@@ -28,227 +25,142 @@ namespace executors
   public:
     /// type-erasure to store the works to do
     typedef  executors::work work;
-  private:
+    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;
+    }
 
-    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:
-  /**
-   * \b Effects: creates a inline executor that runs closures immediately.
-   *
-   * \b Throws: Nothing.
-   */
-  inline_executor()
-  : pimpl(make_shared<shared_state>())
-  {
-  }
+    /// inline_executor is not copyable.
+    BOOST_THREAD_NO_COPYABLE(inline_executor)
 
-  /**
-   * \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: 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 Returns: whether the executor is closed for submissions.
-   */
-  bool closed() const
-  {
-    return pimpl->closed();
-  }
+    /**
+     * \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 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 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.
+     */
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-  template <typename Closure>
-  void submit(Closure & closure)
-  {
-    pimpl->submit(closure);
-  }
+    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)())
-  {
-    pimpl->submit(closure);
-  }
+    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)
-  {
-    pimpl->submit(boost::forward<Closure>(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;
+      }
+    }
 
-  /**
-   * 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& )
+    {
+      return false;
+    }
 
-  /**
-   * \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-2015 Vicente J. Botet Escriba
+// Copyright (C) 2013,2014 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,9 +17,6 @@
 #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
@@ -33,178 +30,59 @@ 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;
 
-    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()
-      {
-        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.
-       */
-
-      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)
-      {
-        //work_queue.push(work(closure));
-        submit(work(closure));
-      }
-  #endif
-      void submit(void (*closure)())
-      {
-        //work_queue.push(work(closure));
-        submit(work(closure));
-      }
-
-      template <typename 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));
-      }
-
-      /**
-       * \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();
-          q.pop_front();
-        }
-      }
-
-    };
   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
+      {
+        if (work_queue.try_pull(task) == queue_op_status::success)
+        {
+          task();
+          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();
+        }
+    }
+
+
+
+
+  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>())
     {
     }
     /**
@@ -214,33 +92,22 @@ 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()
     {
-      pimpl->loop();
+      while (!closed())
+      {
+        schedule_one_or_yield();
+      }
+      while (try_executing_one())
+      {
+      }
     }
 
     /**
@@ -249,7 +116,7 @@ namespace executors
      */
     void close()
     {
-      pimpl->close();
+      work_queue.close();
     }
 
     /**
@@ -257,7 +124,7 @@ namespace executors
      */
     bool closed()
     {
-      return pimpl->closed();
+      return work_queue.closed();
     }
 
     /**
@@ -271,27 +138,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)
     {
-      pimpl->submit(closure);
+      work_queue.push(work(closure));
     }
 #endif
-
     void submit(void (*closure)())
     {
-      pimpl->submit(closure);
+      work_queue.push(work(closure));
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      pimpl->submit(boost::forward<Closure>(closure));
+      work_queue.push(work(boost::forward<Closure>(closure)));
     }
 
     /**
@@ -302,7 +165,13 @@ namespace executors
     template <typename Pred>
     bool reschedule_until(Pred const& pred)
     {
-      return pimpl->reschedule_until(pred);
+      do {
+        if ( ! try_executing_one())
+        {
+          return false;
+        }
+      } while (! pred());
+      return true;
     }
 
     /**
@@ -310,10 +179,15 @@ namespace executors
      */
     void run_queued_closures()
     {
-      pimpl->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();
+      }
     }
-  private:
-    shared_ptr<shared_state> pimpl;
+
   };
 }
 using executors::loop_executor;

include/boost/thread/executors/scheduled_thread_pool.hpp

@@ -9,123 +9,36 @@
 #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
 {
 
-  template <class Clock = chrono::steady_clock>
-  class scheduled_thread_pool
+  class scheduled_thread_pool : public detail::scheduled_executor_base<>
   {
   private:
-
-    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()
-      {
-
-        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
-
+    thread_group _workers;
   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))
+    scheduled_thread_pool(size_t num_threads) : super()
     {
+      for(size_t i = 0; i < num_threads; i++)
+      {
+        _workers.create_thread(bind(&super::loop, this));
+      }
     }
 
-    /**
-     * \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()
     {
-    }
-    /**
-     * \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();
+      this->close();
+      _workers.join_all();
     }
 
-    /**
-     * \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;
-  };
+    typedef detail::scheduled_executor_base<> super;
+  }; //end class
+
 } //end executors namespace
 
 using executors::scheduled_thread_pool;

include/boost/thread/executors/scheduler.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2014-2015 Vicente J. Botet Escriba
+// Copyright (C) 2014 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,8 +13,6 @@
 #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>
 
@@ -38,7 +36,7 @@ namespace boost
       }
 
     private:
-      Executor   ex;
+      Executor&   ex;
       Function funct;
     };
 
@@ -102,8 +100,8 @@ namespace boost
       }
 
     private:
-      Scheduler   sch;
-      Executor   ex;
+      Scheduler&  sch;
+      Executor&   ex;
       typename clock::time_point  tp;
       bool  is_closed;
     };
@@ -152,8 +150,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
@@ -210,7 +208,7 @@ namespace boost
       }
 
     private:
-      Scheduler sch;
+      Scheduler& sch;
       time_point  tp;
       bool  is_closed;
     }; //end class
@@ -219,71 +217,22 @@ 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
+    class scheduler : public detail::scheduled_executor_base<Clock>
     {
-    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 typename detail::scheduled_executor_base<Clock>::work work;
+
       typedef Clock clock;
-      typedef typename clock::duration duration;
-      typedef typename clock::time_point time_point;
 
       scheduler()
-        : pimpl(make_shared<shared_state>())
-      {}
+        : super(),
+          thr(&super::loop, this) {}
 
       ~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)
       {
@@ -301,10 +250,13 @@ namespace boost
       {
         return at_executor<scheduler>(*this, tp);
       }
+
     private:
-      shared_ptr<shared_state> pimpl;
+      typedef detail::scheduled_executor_base<Clock> super;
+      thread thr;
     };
 
+
   }
   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,2015 Vicente J. Botet Escriba
+// Copyright (C) 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)
@@ -14,179 +14,116 @@
 #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/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
   {
   public:
     /// type-erasure to store the works to do
     typedef  executors::work work;
   private:
+    typedef  scoped_thread<> thread_t;
 
-    struct shared_state {
-      typedef  executors::work work;
-      //typedef  scoped_thread<> thread_t;
-      typedef thread thread_t;
+    /// the thread safe work queue
+    concurrent::sync_queue<work > work_queue;
+    generic_executor_ref ex;
+    thread_t thr;
 
-      /// 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
+    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 (...)
         {
-          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;
+          p.set_exception(current_exception());
         }
       }
-
-    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();
-        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()
-      {
-        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.
-       */
-
-      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)
-      {
-        //work_queue.push(work(closure));
-        submit(work(closure));
-      }
-  #endif
-      void submit(void (*closure)())
-      {
-        //work_queue.push(work(closure));
-        submit(work(closure));
-      }
-
-      template <typename Closure>
-      void submit(BOOST_THREAD_FWD_REF(Closure) closure)
-      {
-        //work_queue.push(work(boost::move(closure)));
-        work w((boost::forward<Closure>(closure)));
-        submit(boost::move(w));
-      }
-
     };
+  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)
-    : pimpl(make_shared<shared_state>(ex))
+    : ex(ex), thr(&serial_executor::worker_thread, this)
     {
     }
     /**
@@ -196,24 +133,8 @@ namespace executors
      */
     ~serial_executor()
     {
-    }
-
-    /**
-     * \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;
+      // signal to the worker thread that there will be no more submissions.
+      close();
     }
 
     /**
@@ -222,7 +143,7 @@ namespace executors
      */
     void close()
     {
-      pimpl->close();
+      work_queue.close();
     }
 
     /**
@@ -230,7 +151,7 @@ namespace executors
      */
     bool closed()
     {
-      return pimpl->closed();
+      return work_queue.closed();
     }
 
     /**
@@ -244,40 +165,42 @@ 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)
     {
-      pimpl->submit(closure);
+      work_queue.push(work(closure));
     }
 #endif
     void submit(void (*closure)())
     {
-      pimpl->submit(closure);
+      work_queue.push(work(closure));
     }
 
     template <typename Closure>
-    void submit(BOOST_THREAD_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      pimpl->submit(boost::forward<Closure>(closure));
+      work_queue.push(work(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.
+     * \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)
     {
-      return false;
+      do {
+        if ( ! try_executing_one())
+        {
+          return false;
+        }
+      } while (! pred());
+      return true;
     }
-  private:
-    shared_ptr<shared_state> pimpl;
+
   };
 }
 using executors::serial_executor;

include/boost/thread/executors/serial_executor_cont.hpp

@@ -12,20 +12,18 @@
 #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:
@@ -33,156 +31,93 @@ namespace executors
     typedef  executors::work work;
   private:
 
-    struct shared_state {
-      typedef  executors::work work;
+    generic_executor_ref ex_;
+    future<void> fut_; // protected by mtx_
+    bool closed_; // protected by mtx_
+    mutex mtx_;
 
-      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();
-          }
-        }
+    struct continuation {
+      work task;
+      template <class X>
+      struct result {
+        typedef void type;
       };
-
-      bool closed(lock_guard<mutex>&) const
+      continuation(BOOST_THREAD_RV_REF(work) tsk)
+      : task(boost::move(tsk)) {}
+      void operator()(future<void> f)
       {
-        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))));
+        try {
+          task();
+        } catch (...)  {
+          std::terminate();
+        }
       }
     };
+
+    bool closed(lock_guard<mutex>&) const
+    {
+      return closed_;
+    }
   public:
     /**
-     * \b Effects: creates a thread pool that runs closures using one of its closure-executing methods.
+     * \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 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)
-    : pimpl(make_shared<shared_state>(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 destructor.
+     * \b Synchronization: The completion of all the closures happen before the completion of the \c serial_executor_cont destructor.
      */
     ~serial_executor_cont()
     {
+      // signal to the worker thread that there will be no more submissions.
+      close();
     }
 
     /**
-     * \par Returns
-     * The underlying executor wrapped on a generic executor reference.
+     * \b Effects: close the \c serial_executor_cont for submissions.
+     * The loop will work until there is no more closures to run.
      */
-    Executor& underlying_executor() BOOST_NOEXCEPT
+    void close()
     {
-      return pimpl->underlying_executor();
+      lock_guard<mutex> lk(mtx_);
+      closed_ = true;;
     }
 
     /**
-     * \b Returns: always false as a serial executor can not re-enter.
+     * \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.
      * Remark: A serial executor can not execute one of its pending tasks as the tasks depends on the other tasks.
      */
     bool try_executing_one()
@@ -190,64 +125,41 @@ 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 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 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 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.
+     * \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)
     {
-      pimpl->submit(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)())
     {
-      pimpl->submit(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_FWD_REF(Closure) closure)
+    void submit(BOOST_THREAD_RV_REF(Closure) closure)
     {
-      pimpl->submit(boost::forward<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))));
     }
 
-    /**
-     * \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-2015 Vicente J. Botet Escriba
+// Copyright (C) 2014 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,9 +18,6 @@
 #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>
-
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
@@ -32,148 +29,33 @@ namespace executors
   public:
     /// type-erasure to store the works to do
     typedef  executors::work work;
-  private:
+    bool closed_;
+    typedef scoped_thread<> thread_t;
+    typedef csbl::vector<thread_t> threads_type;
+    threads_type threads_;
+    mutable mutex mtx_;
 
-    struct shared_state {
-      typedef  executors::work work;
-      bool closed_;
-      //typedef scoped_thread<> thread_t;
-      typedef thread thread_t;
-      typedef csbl::vector<thread_t> threads_type;
-      threads_type threads_;
-      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;
+    }
 
-      /// thread_executor::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: 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
-        join();
-      }
-
-      /**
-       * \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();
-        }
-      }
-
-      /**
-       * 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()
-    : pimpl(make_shared<shared_state>())
+    : closed_(false)
     {
     }
     /**
@@ -183,16 +65,9 @@ namespace executors
      */
     ~thread_executor()
     {
-    }
-
-    /**
-     * 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();
+      // signal to all the worker thread that there will be no more submissions.
+      close();
+      // all the scoped threads will join before destroying
     }
 
     /**
@@ -201,15 +76,21 @@ namespace executors
      */
     void close()
     {
-      pimpl->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()
     {
-      return pimpl->closed();
+      lock_guard<mutex> lk(mtx_);
+      return closed(lk);
     }
 
     /**
@@ -228,18 +109,30 @@ namespace executors
     template <typename Closure>
     void submit(Closure & closure)
     {
-      pimpl->submit(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)())
     {
-      pimpl->submit(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)
     {
-      pimpl->submit(boost::forward<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)));
     }
 
     /**
@@ -248,14 +141,12 @@ namespace executors
      * \b Effects: reschedule functions until pred()
      */
     template <typename Pred>
-    bool reschedule_until(Pred const& p)
+    bool reschedule_until(Pred const&)
     {
-      return pimpl->reschedule_until(p);
+      return false;
     }
-  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 const&, BOOST_THREAD_FWD_REF(F) f);
+    friend void task_region(Ex&, BOOST_THREAD_FWD_REF(F) f);
     template<class Ex, typename F>
-    friend void task_region_final(Ex const&, BOOST_THREAD_FWD_REF(F) f);
+    friend void task_region_final(Ex&, BOOST_THREAD_FWD_REF(F) f);
 
     void wait_all()
     {
@@ -153,20 +153,21 @@ 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 const& ex)
+    task_region_handle_gen(Executor& 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 const& ex)
-    : ex(ex)
+    task_region_handle_gen(Executor& ex)
+    : ex(&ex)
     {}
 #endif
 
@@ -187,7 +188,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;
@@ -210,13 +211,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
@@ -244,18 +245,17 @@ 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 const& ex, BOOST_THREAD_FWD_REF(F) f)
+  void task_region_final(Executor& 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 const& ex, BOOST_THREAD_FWD_REF(F) f)
+  void task_region(Executor& ex, BOOST_THREAD_FWD_REF(F) f)
   {
     task_region_final(ex, forward<F>(f));
   }

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

@@ -156,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()
@@ -240,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
@@ -270,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(
@@ -370,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(
@@ -378,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
 

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,
@@ -139,15 +120,6 @@ namespace boost
             unique_lock<mutex>& m,
             duration_type const& wait_duration)
         {
-            if (wait_duration.is_pos_infinity())
-            {
-                wait(m); // or do_wait(m,detail::timeout::sentinel());
-                return true;
-            }
-            if (wait_duration.is_special())
-            {
-                return true;
-            }
             return timed_wait(m,get_system_time()+wait_duration);
         }
 
@@ -177,24 +149,10 @@ namespace boost
             unique_lock<mutex>& m,
             duration_type const& wait_duration,predicate_type pred)
         {
-            if (wait_duration.is_pos_infinity())
-            {
-                while (!pred())
-                {
-                  wait(m); // or do_wait(m,detail::timeout::sentinel());
-                }
-                return true;
-            }
-            if (wait_duration.is_special())
-            {
-                return pred();
-            }
             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 Duration>
@@ -224,6 +182,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 +213,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 +222,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 +242,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/pthread/thread_data.hpp

@@ -13,8 +13,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/pthread/condition_variable_fwd.hpp>
 
-//#include <boost/shared_ptr.hpp>
-#include <boost/thread/csbl/memory/shared_ptr.hpp>
+#include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/assert.hpp>
 #ifdef BOOST_THREAD_USES_CHRONO
@@ -128,7 +127,7 @@ namespace boost
             > notify_list_t;
             notify_list_t notify;
 
-            typedef std::vector<csbl::shared_ptr<shared_state_base> > async_states_t;
+            typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
             async_states_t async_states_;
 
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
@@ -163,7 +162,7 @@ namespace boost
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
 
-            void make_ready_at_thread_exit(csbl::shared_ptr<shared_state_base> as)
+            void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
             {
               async_states_.push_back(as);
             }

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,7 +91,7 @@ namespace boost
         cv.wait_until(lk, t);
     }
 
-#if defined BOOST_THREAD_SLEEP_FOR_IS_STEADY && ! defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
+#ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY
 
     template <class Rep, class Period>
     void sleep_for(const chrono::duration<Rep, Period>& d)

include/boost/thread/win32/condition_variable.hpp

@@ -339,8 +339,8 @@ namespace boost
         {
           if (wait_duration.is_pos_infinity())
           {
-            wait(m); // or do_wait(m,detail::timeout::sentinel());
-            return true;
+              wait(m); // or do_wait(m,detail::timeout::sentinel());
+              return true;
           }
           if (wait_duration.is_special())
           {
@@ -362,18 +362,6 @@ namespace boost
         template<typename duration_type,typename predicate_type>
         bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred)
         {
-            if (wait_duration.is_pos_infinity())
-            {
-              while (!pred())
-              {
-                wait(m); // or do_wait(m,detail::timeout::sentinel());
-              }
-              return true;
-            }
-            if (wait_duration.is_special())
-            {
-              return pred();
-            }
             return do_wait(m,wait_duration.total_milliseconds(),pred);
         }
 #endif

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,7 @@
 #include <pthread.h>
 #include <stdlib.h>
 #include <memory>
-#include <string.h> // memcmp.
+
 namespace boost
 {
     namespace thread_detail
@@ -42,6 +42,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 +58,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
 {
@@ -81,8 +80,6 @@ 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();
-
                     if(thread_info)
                     {
                         while(!thread_info->tss_data.empty() || thread_info->thread_exit_callbacks)
@@ -118,6 +115,8 @@ namespace boost
                 }
             }
 
+#if defined BOOST_THREAD_PATCH
+
             struct  delete_current_thread_tls_key_on_dlclose_t
             {
                 delete_current_thread_tls_key_on_dlclose_t()
@@ -125,14 +124,14 @@ namespace boost
                 }
                 ~delete_current_thread_tls_key_on_dlclose_t()
                 {
-                    const boost::once_flag uninitialized = BOOST_ONCE_INIT;
-                    if (memcmp(&current_thread_tls_init_flag, &uninitialized, sizeof(boost::once_flag)))
+                    if (current_thread_tls_init_flag.epoch!=BOOST_ONCE_INITIAL_FLAG_VALUE)
                     {
                         pthread_key_delete(current_thread_tls_key);
                     }
                 }
             };
             delete_current_thread_tls_key_on_dlclose_t delete_current_thread_tls_key_on_dlclose;
+#endif
 
             void create_current_thread_tls_key()
             {
@@ -159,9 +158,8 @@ namespace boost
         {
             static void* thread_proxy(void* param)
             {
-                //boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->self;
-                boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->shared_from_this();
-                thread_info->self.reset();
+                boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->self;
+                //thread_info->self.reset();
                 detail::set_current_thread_data(thread_info.get());
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 BOOST_TRY
@@ -254,6 +252,7 @@ namespace boost
         {
             thread_info->self.reset();
             return false;
+//            boost::throw_exception(thread_resource_error(res, "boost thread: failed in pthread_create"));
         }
         return true;
     }
@@ -267,6 +266,7 @@ namespace boost
         {
             thread_info->self.reset();
             return false;
+//            boost::throw_exception(thread_resource_error(res, "boost thread: failed in pthread_create"));
         }
         int detached_state;
         res = pthread_attr_getdetachstate(h, &detached_state);
@@ -274,6 +274,7 @@ namespace boost
         {
             thread_info->self.reset();
             return false;
+//            boost::throw_exception(thread_resource_error(res, "boost thread: failed in pthread_attr_getdetachstate"));
         }
         if (PTHREAD_CREATE_DETACHED==detached_state)
         {
@@ -830,7 +831,7 @@ namespace boost
     }
 namespace detail {
 
-    void BOOST_THREAD_DECL make_ready_at_thread_exit(csbl::shared_ptr<shared_state_base> as)
+    void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
     {
       detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
       if(current_thread_data)

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

@@ -298,7 +298,6 @@ rule thread-compile ( sources : reqs * : name )
           [ thread-compile test_10963.cpp : : test_10963_c ]
           [ thread-run test_10964.cpp ]
           [ thread-test test_11053.cpp ]
-          [ thread-run test_11266.cpp ]
     ;
 
 
@@ -810,11 +809,8 @@ 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/generic_serial_executor_cont.cpp : ex_generic_serial_executor_cont ]
-          #[ thread-run2 ../example/serial_executor_cont.cpp : ex_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 ]
@@ -951,25 +947,11 @@ rule thread-compile ( sources : reqs * : name )
           [ thread-run2-noit ./experimental/parallel/v2/task_region_pass.cpp : task_region_p ]
     ;
     
-    explicit ts_other ;
-    test-suite ts_other
+    explicit ts_ ;
+    test-suite ts_
     :
           [ thread-run2 ../example/this_executor.cpp : ex_this_executor ]
           [ thread-run2 ../example/default_executor.cpp : ex_default_executor ]
     ;
 
-    explicit ts_ ;
-    test-suite ts_
-    :
-          #[ thread-run test_11256.cpp ] 
-          #[ thread-run2 ../example/generic_serial_executor_cont.cpp : ex_generic_serial_executor_cont2 ]
-          #[ thread-run2 ../example/serial_executor_cont.cpp : ex_serial_executor_cont2 ]
-          #[ thread-run test_11256.cpp ]
-          #[ thread-run test_11499.cpp ]
-          #[ thread-run test_11611.cpp ]
-          #[ thread-run test_11633.cpp ]
-          
-    ;
-
-
 }

test/sync/futures/future/then_deferred_pass.cpp

@@ -17,7 +17,6 @@
 
 #include <boost/thread/future.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
@@ -32,8 +31,6 @@ int p1()
 
 int p2(boost::future<int> f)
 {
-  assert(f.is_ready());
-
   BOOST_THREAD_LOG << "p2 <" << &f << BOOST_THREAD_END_LOG;
   BOOST_TEST(f.valid());
   int i = f.get();
@@ -44,7 +41,6 @@ int p2(boost::future<int> f)
 
 void p3(boost::future<int> f)
 {
-  assert(f.is_ready());
   BOOST_THREAD_LOG << "p3 <" << &f << BOOST_THREAD_END_LOG;
   BOOST_TEST(f.valid());
   int i = f.get();

test/sync/futures/future/then_executor_pass.cpp

@@ -20,7 +20,6 @@
 #include <boost/thread/executors/basic_thread_pool.hpp>
 #include <boost/thread/executor.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
@@ -35,7 +34,6 @@ int p1()
 
 int p2(boost::future<int> f)
 {
-  assert(f.is_ready());
   BOOST_THREAD_LOG << "p2 <" << &f << BOOST_THREAD_END_LOG;
   BOOST_TEST(f.valid());
   int i = f.get();
@@ -46,7 +44,6 @@ int p2(boost::future<int> f)
 
 void p3(boost::future<int> f)
 {
-  assert(f.is_ready());
   BOOST_THREAD_LOG << "p3 <" << &f << BOOST_THREAD_END_LOG;
   BOOST_TEST(f.valid());
   int i = f.get();
@@ -117,14 +114,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/recursive_mutex/native_handle_pass.cpp

@@ -29,7 +29,7 @@ int main()
   boost::recursive_mutex::native_handle_type h = m.native_handle();
   BOOST_TEST(h);
 #else
-#error "Test not applicable: BOOST_THREAD_DEFINES_RECURSIVE_MUTEX_NATIVE_HANDLE not defined for this platform as not supported"
+#error "Test not applicable: BOOST_THREAD_DEFINES_CONDITION_VARIABLE_NATIVE_HANDLE not defined for this platform as not supported"
 #endif
 
   return boost::report_errors();

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_10963.cpp

@@ -8,12 +8,9 @@
 #if ! defined  BOOST_NO_CXX11_DECLTYPE
 #define BOOST_RESULT_OF_USE_DECLTYPE
 #endif
-#define BOOST_THREAD_PROVIDES_EXECUTORS
 
 #include <boost/thread/future.hpp>
 #include <boost/static_assert.hpp>
-#include <cassert>
-#include <boost/thread/executors/basic_thread_pool.hpp>
 
 
 struct TestCallback
@@ -22,14 +19,12 @@ struct TestCallback
 
     result_type operator()(boost::future<void> future) const
     {
-      assert(future.is_ready());
         future.get();
         return boost::make_ready_future();
     }
 
     result_type operator()(boost::future<boost::future<void> > future) const
     {
-      assert(future.is_ready());
        future.get();
        return boost::make_ready_future();
     }
@@ -38,24 +33,12 @@ struct TestCallback
 int main()
 {
 #if ! defined  BOOST_NO_CXX11_DECLTYPE && ! defined  BOOST_NO_CXX11_AUTO_DECLARATIONS
-  {
     boost::promise<void> test_promise;
     boost::future<void> test_future(test_promise.get_future());
     auto f1 = test_future.then(TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
     auto f2 = f1.then(TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<boost::future<void> > >::value);
-  }
-  {
-    boost::basic_thread_pool executor;
-    boost::promise<void> test_promise;
-    boost::future<void> test_future(test_promise.get_future());
-    auto f1 = test_future.then(executor, TestCallback());
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
-    auto f2 = f1.then(executor, TestCallback());
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<boost::future<void> > >::value);
-
-  }
 #endif
     return 0;
 }

test/test_10964.cpp

@@ -8,12 +8,9 @@
 #if ! defined  BOOST_NO_CXX11_DECLTYPE
 #define BOOST_RESULT_OF_USE_DECLTYPE
 #endif
-#define BOOST_THREAD_PROVIDES_EXECUTORS
 
 #include <boost/thread/future.hpp>
 #include <boost/static_assert.hpp>
-#include <cassert>
-#include <boost/thread/executors/basic_thread_pool.hpp>
 
 struct TestCallback
 {
@@ -21,23 +18,13 @@ struct TestCallback
 
   result_type operator()(boost::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;
+    future.get();
     return boost::make_ready_future();
   }
 
   result_type operator()(boost::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();
-
+    future.get();
     return boost::make_ready_future();
   }
 };
@@ -48,9 +35,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;
   {
@@ -59,108 +43,34 @@ int main()
     f1.wait();
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-  for (int i=0; i< number_of_tests; i++)
   {
     auto f1 = boost::make_ready_future().then(TestCallback());
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     auto f2 = f1.unwrap();
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<void> >::value);
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     f2.wait();
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-  for (int i=0; i< number_of_tests; i++)
-  {
-    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;
-  for (int i=0; i< number_of_tests; i++)
   {
     auto f1 = boost::make_ready_future().then(TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
     auto f2 = f1.unwrap();
     BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<void> >::value);
     auto f3 = f2.then(TestCallback());
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
+    BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-  for (int i=0; i< number_of_tests; i++)
   {
         boost::make_ready_future().then(
             TestCallback()).unwrap().then(TestCallback()).get();
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-  for (int i=0; i< number_of_tests; i++)
   {
     boost::future<void> f = boost::async(p1);
     f.then(
             TestCallback()).unwrap().then(TestCallback()).get();
   }
-  std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-  for (int i=0; i< number_of_tests; i++)
-  {
-    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;
-  for (int i=0; i< number_of_tests; i++)
-  {
-    boost::basic_thread_pool executor;
-    auto f1 = boost::make_ready_future().then(executor, TestCallback());
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
-    auto f3 = f1.then(executor, TestCallback());
-    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++)
-  {
-    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);
-    std::cout << __FILE__ << "[" << __LINE__ << "] " << int(f1.valid()) << std::endl;
-    auto f2 = f1.unwrap();
-    std::cout << __FILE__ << "[" << __LINE__ << "] " << int(f2.valid()) << std::endl;
-
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<void> >::value);
-    auto f3 = f2.then(executor, TestCallback());
-    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++)
-  {
-    boost::basic_thread_pool executor;
-
-    auto f1 = boost::make_ready_future().then(executor, TestCallback());
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
-    auto f2 = f1.unwrap();
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<void> >::value);
-    auto f3 = f2.then(executor, TestCallback());
-    BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
-    f3.wait();
-  }
-  std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-
 #endif
   return 0;
 }

test/test_11256.cpp

@@ -1,42 +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)
-
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
-
-#include <boost/thread.hpp>
-#include <boost/thread/thread_pool.hpp>
-#include <cassert>
-
-auto createFuture()
-{
-    boost::promise<void> promise;
-    promise.set_value();
-    return promise.get_future();
-}
-
-auto stepOne(boost::basic_thread_pool &executor)
-{
-    auto sendFuture = createFuture();
-    auto wrappedFuture = sendFuture.then(executor, [](auto f) mutable {
-        return createFuture();
-    });
-
-    return wrappedFuture.unwrap();
-}
-
-auto stepTwo(boost::basic_thread_pool &executor)
-{
-    auto future = stepOne(executor);
-    return future.then(executor, [](auto f) {
-        assert(f.is_ready());
-    });
-}
-
-int main()
-{
-    boost::basic_thread_pool executor{1};
-    stepTwo(executor).get();
-}

test/test_11266.cpp

@@ -1,29 +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)
-
-#define BOOST_THREAD_VERSION 4
-
-#include <boost/thread/future.hpp>
-
-void func(int) { }
-
-int main()
-{
-#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
-  {
-  boost::packaged_task<void(int)> task{func};
-  }
-  {
-    boost::packaged_task<void(int)> task{func};
-
-    task(0);
-  }
-  {
-    boost::packaged_task<void(int)> task{func};
-    int x = 0;
-    task(x);
-  }
-#endif
-}

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<boost::loop_executor> serial(ex);
-     boost::serial_executor<boost::loop_executor> serial(ex);
-
-      for (size_t i = 0; i < 1000000; i++)
-         serial.submit([i] {
-             //std::cout << i << ".";
-         });
-
-      serial.close();
-   }
-
-   ex.close();
-
-   t.join();
-   std::cout << "end" << std::endl;
-   return 0;
-}

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,18 +46,19 @@ 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);
@@ -84,10 +85,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,6 +27,7 @@ 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;
 }
 
@@ -74,7 +75,7 @@ int main()
   test_after(5, sch);
   test_at(5, sch);
   test_on(5, sch, tp);
-  std::cout << "[" << __LINE__ << "] " << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::seconds(10));
 
   return boost::report_errors();
 }

test/test_scheduling_adaptor.cpp

@@ -28,6 +28,7 @@ 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;
 }
 
@@ -40,10 +41,14 @@ 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);

test/threads/thread/constr/FArgs_pass.cpp

@@ -26,9 +26,9 @@
 unsigned throw_one = 0xFFFF;
 
 #if defined _GLIBCXX_THROW
-inline void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
+void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
 #elif defined BOOST_MSVC
-inline void* operator new(std::size_t s)
+void* operator new(std::size_t s)
 #else
 void* operator new(std::size_t s) throw (std::bad_alloc)
 #endif
@@ -40,9 +40,9 @@ void* operator new(std::size_t s) throw (std::bad_alloc)
 }
 
 #if defined BOOST_MSVC
-inline void operator delete(void* p)
+void operator delete(void* p)
 #else
-inline void operator delete(void* p) throw ()
+void operator delete(void* p) throw ()
 #endif
 {
   std::cout << __FILE__ << ":" << __LINE__ << std::endl;

test/threads/thread/constr/lambda_pass.cpp

@@ -28,9 +28,9 @@
 unsigned throw_one = 0xFFFF;
 
 #if defined _GLIBCXX_THROW
-inline void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
+void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
 #elif defined BOOST_MSVC
-inline void* operator new(std::size_t s)
+void* operator new(std::size_t s)
 #else
 void* operator new(std::size_t s) throw (std::bad_alloc)
 #endif
@@ -41,9 +41,9 @@ void* operator new(std::size_t s) throw (std::bad_alloc)
 }
 
 #if defined BOOST_MSVC
-inline void operator delete(void* p)
+void operator delete(void* p)
 #else
-inline void operator delete(void* p) throw ()
+void operator delete(void* p) throw ()
 #endif
 {
   std::free(p);