Merge branch 'develop'

Fixed some documentation bugs.

doc/async_executors.qbk

@@ -319,33 +319,23 @@ The reason is that the user can always use a thread_local variable and reset it
 		}
 	);
 
+[
 [heading Default executor]
 
 The library authors share some of the concerns of the C++ standard committee (introduction of a new single shared resource, a singleton, could make it difficult to make it portable to all the environments) and that this library doesn't need to provide a default executor for the time been. 
 
-The user can always define his default executor himself and use the `at_thread_entry ` member function to set the default constructor.
+The user can always define his default executor himself.
 
-	thread_local default_executor_state_type default_executor_state;
+	boost::generic_executor_ref default_executor()
-	executor* default_executor() { return default_executor_state.default_executor(); }
+	{
-
+  		static boost::basic_thread_pool tp(4);
-	// in main
+  		return generic_executor_ref(tp);
-	MyDefaultExecutor myDefaultExecutor( 
+	}
-		// at_thread_entry
-		[](MyDefaultExecutor& ex) { 
-			default_executor_state.set_default_executor(ex);
-		}
-	);
-
-	basic_thread_pool pool(
-		// at_thread_entry
-		[&myDefaultExecutor](basic_thread_pool& pool) { 
-			default_executor_state.set_default_executor(myDefaultExecutor);
-		}
-	);
 
 
 [endsect]
 
+
 [/////////////////////]
 [section:ref Reference]
 

doc/changes.qbk

@@ -14,40 +14,39 @@
 
 * [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
 * [@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/6787 #6787] boost::thread::sleep() hangs if system time is rolled back
-* [@http://svn.boost.org/trac/boost/ticket/7319 #7319] Take care of c++std-lib-32966 issue
 * [@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/9309 #9309] test_latch fails often on clang-darwin-tot11
 * [@http://svn.boost.org/trac/boost/ticket/9311 #9311] ex_lambda_future fails on msvc-11.0
-* [@http://svn.boost.org/trac/boost/ticket/9856 #9856] [windows] condition_variable::wait_for returns wrong cv_status on timeout.
+* [@http://svn.boost.org/trac/boost/ticket/10942 #10942] Boost.Thread fails to build on Cygwin.
+
+[/
+* [@http://svn.boost.org/trac/boost/ticket/7319 #7319] Take care of c++std-lib-32966 issue
 * [@http://svn.boost.org/trac/boost/ticket/10651 #10651] boost::thread leaks memory when using the MinGW compiler.
 * [@http://svn.boost.org/trac/boost/ticket/10685 #10685] mfc_thread_init.hpp does not compile.
-* [@http://svn.boost.org/trac/boost/ticket/10942 #10942] Boost.Thread fails to build on Cygwin.
 * [@http://svn.boost.org/trac/boost/ticket/10967 #10967] Timed wait points inconsistently convert relative to absolute waits.
-* [@http://svn.boost.org/trac/boost/ticket/10968 #10968] The futures returned by async() and future::then() are not blocking.
+]
 
 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 snapshot.
+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.
 
 [*Sever limitations:]
 
 There are some severe bugs that prevent the use of the library on concrete contexts, in particular:
 
 * on thread specific storage that prevent the library to be used with dynamic libraries ( [@http://svn.boost.org/trac/boost/ticket/3926 #3926], ),
-* timed operation on windows are inconsistent ( [@http://svn.boost.org/trac/boost/ticket/9856 #9856], [@http://svn.boost.org/trac/boost/ticket/10967 #10967]).
-* The futures returned by async() and future::then() are not blocking ([@http://svn.boost.org/trac/boost/ticket/10968 #10968]).
 
 [*New Experimental Features:]
 
 * [@http://svn.boost.org/trac/boost/ticket/9600 #9600] Async: Add task_region
 * [@http://svn.boost.org/trac/boost/ticket/10611 #10611] Add emplace promise::set_value and emplace make_ready_future
 * [@http://svn.boost.org/trac/boost/ticket/10826 #10826] Add scheduled executor operations
+* [@http://svn.boost.org/trac/boost/ticket/11048 #11048] Add a serial_executor based on continuations
 
 [*Fixed Bugs:]
 
-
+* [@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/10734 #10734] Submit method work differently on different executors, some throw exception and some silently ignore error (thread_executor and inline_executor)
 * [@http://svn.boost.org/trac/boost/ticket/10736 #10736] Task exceptions silently ignored. I think std::terminate solution from N3785 and std::thread is better choice and more consistent.
 * [@http://svn.boost.org/trac/boost/ticket/10737 #10737] In serial_executor we have infinite wait if task throw exception.
@@ -55,9 +54,13 @@ There are some severe bugs that prevent the use of the library on concrete conte
 * [@http://svn.boost.org/trac/boost/ticket/10824 #10824] Boost.Thread 1.57 breaks Windows XP compatibility for SP2 and below.
 * [@http://svn.boost.org/trac/boost/ticket/10963 #10963] future<future<T>>::then Has No Implementation
 * [@http://svn.boost.org/trac/boost/ticket/10964 #10964] future<future<T>>::unwrap().then() Deadlocks
+* [@http://svn.boost.org/trac/boost/ticket/10968 #10968] The futures returned by async() and future::then() are not blocking.
 * [@http://svn.boost.org/trac/boost/ticket/10971 #10971] shared_future::get()/get_or() must be const
 * [@http://svn.boost.org/trac/boost/ticket/10972 #10972] shared_future::then() can be called multiple times.
 * [@http://svn.boost.org/trac/boost/ticket/10979 #10979] Support T& type deduction when the make_ready_future parameter is reference_wrapper<T>
+* [@http://svn.boost.org/trac/boost/ticket/10996 #10996] Thread physical_concurrency() is failing on Windows
+* [@http://svn.boost.org/trac/boost/ticket/11035 #11035] BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE not defined for Android
+* [@http://svn.boost.org/trac/boost/ticket/11053 #11053] The attached code results in a R6025 - pure virtual function call in run_thread_exit_callbacks
 
 
 [heading Version 4.4.0 - boost 1.57]
@@ -76,6 +79,7 @@ There are some severe bugs that prevent the use of the library on concrete conte
 * [@http://svn.boost.org/trac/boost/ticket/10537 #10537] Application crash on throw exception
 * [@http://svn.boost.org/trac/boost/ticket/10651 #10651] boost::thread leaks memory when using the MinGW compiler
 
+
 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 snapshot.

doc/external_locking.qbk

@@ -98,7 +98,7 @@ or inheriting from a class which add these lockable functions.
 The `basic_lockable_adapter` class helps to define the `BankAccount` class as
 
   class BankAccount
-  : public basic_lockable_adapter<thread_mutex>
+  : public basic_lockable_adapter<boost::mutex>
   {
       int balance_;
   public:
@@ -138,7 +138,7 @@ Notice that now acct is being locked by Withdraw after it has already been locke
 As `boost::mutex` is not recursive, we need to use its recursive version `boost::recursive_mutex`.
 
   class BankAccount
-  : public basic_lockable_adapter<recursive_mutex>
+  : public basic_lockable_adapter<boost::recursive_mutex>
   {
   
       // ...
@@ -147,7 +147,7 @@ As `boost::mutex` is not recursive, we need to use its recursive version `boost:
 The caller-ensured locking approach is more flexible and the most efficient, but very dangerous. In an implementation using caller-ensured locking, BankAccount still holds a mutex, but its member functions don't manipulate it at all. Deposit and Withdraw are not thread-safe anymore. Instead, the client code is responsible for locking BankAccount properly.
 
     class BankAccount
-        : public basic_lockable_adapter<boost:mutex> {
+        : public basic_lockable_adapter<boost::mutex> {
         int balance_;
     public:
         void Deposit(int amount) {
@@ -271,7 +271,7 @@ Now that we have such a strict `strict_lock`, how do we harness its power in def
 A little code is worth 1,000 words, a (hacked into) saying goes, so here's the new BankAccount class:
 
     class BankAccount
-    : public basic_lockable_adapter<boost:recursive_mutex>
+    : public basic_lockable_adapter<boost::mutex>
     {
         int balance_;
     public:
@@ -280,7 +280,7 @@ A little code is worth 1,000 words, a (hacked into) saying goes, so here's the n
             balance_ += amount;
         }
         void Deposit(int amount) {
-            strict_lock<boost:mutex> guard(*this); // Internally locked
+            strict_lock<BankAccount> guard(*this); // Internally locked
             Deposit(amount, guard);
         }
         void Withdraw(int amount, strict_lock<BankAccount>&) {
@@ -288,7 +288,7 @@ A little code is worth 1,000 words, a (hacked into) saying goes, so here's the n
             balance_ -= amount;
         }
         void Withdraw(int amount) {
-            strict_lock<boost:mutex> guard(*this); // Internally locked
+            strict_lock<BankAccount> guard(*this); // Internally locked
             Withdraw(amount, guard);
         }
     };
@@ -327,7 +327,7 @@ The scheme is useful because the likelihood of a programmer forgetting about any
 Using `strict_lock` permits compile-time checking of the most common source of errors, and runtime checking of the less frequent problem.
 
 Let's see how to enforce that the appropriate BankAccount object is locked. First, we need to add a member function to the `strict_lock` class template. 
-The `bool strict_lock<T>::owns_lock(Loclable*)` function returns a reference to the locked object.
+The `bool strict_lock<T>::owns_lock(Lockable*)` function returns a reference to the locked object.
 
     template <class Lockable> class strict_lock {
         ... as before ...
@@ -338,7 +338,7 @@ The `bool strict_lock<T>::owns_lock(Loclable*)` function returns a reference to
 Second, BankAccount needs to use this function compare the locked object against this:
 
     class BankAccount {
-    : public basic_lockable_adapter<boost::recursive_mutex>
+    : public basic_lockable_adapter<boost::mutex>
         int balance_;
     public:
         void Deposit(int amount, strict_lock<BankAccount>& guard) {
@@ -403,7 +403,7 @@ The solution is to use a little bridge template `externally_locked` that control
       T& get(strict_lock<Lockable>& lock) {
   
   #ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
-          if (!lock.owns_lock(&lockable_)) throw lock_error(); run time check throw if not locks the same
+          if (!lock.owns_lock(&lockable_)) throw lock_error(); //run time check throw if not locks the same
   #endif
           return obj_;
       }
@@ -421,10 +421,10 @@ The solution is to use a little bridge template `externally_locked` that control
 Instead of making `checkingAcct_` and `savingsAcct_` of type `BankAccount`, `AccountManager` holds objects of type `externally_locked<BankAccount, AccountManager>`:
 
   class AccountManager
-      : public basic_lockable_adapter<thread_mutex>
+      : public basic_lockable_adapter<boost::mutex>
   {
   public:
-      typedef basic_lockable_adapter<thread_mutex> lockable_base_type;
+      typedef basic_lockable_adapter<boost::mutex> lockable_base_type;
       AccountManager()
           : checkingAcct_(*this)
           , savingsAcct_(*this)
@@ -498,7 +498,7 @@ Now we need to state that both classes are `strict_lock`s.
 
 Well let me show what this `nested_strict_lock` class looks like and the impacts on the `externally_locked` class and the `AccountManager::AMoreComplicatedFunction` function.
 
-First `nested_strict_lock` class will store on a temporary lock the `Locker`, and transfer the lock ownership on the constructor. On destruction it will restore the ownership. Note the use of `lock_traits` and that the `Locker` needs to have a reference to the mutex otherwise and exception is thrown.
+First `nested_strict_lock` class will store on a temporary lock the `Locker`, and transfer the lock ownership on the constructor. On destruction it will restore the ownership. Note the use of `lock_traits` and that the `Locker` needs to have a reference to the mutex otherwise an exception is thrown.
 
   template <typename Locker >
   class nested_strict_lock
@@ -510,7 +510,7 @@ First `nested_strict_lock` class will store on a temporary lock the `Locker`, an
   
       nested_strict_lock(Locker& lock)
           : lock_(lock)  // Store reference to locker
-          , tmp_lock_(lock.move()) // Move ownership to temporaty locker 
+          , tmp_lock_(lock.move()) // Move ownership to temporary locker 
       {
           #ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
           if (tmp_lock_.mutex()==0) {

doc/mutex_concepts.qbk

@@ -2664,7 +2664,7 @@ Only the specificities respect to __Lockable are described here.
 
 [endsect]
 [///////////////////////////////]
-[section:get2 `get(strict_lock<nested_strict_lock<Lock>>&)`]
+[section:get2 `get(nested_strict_lock<Lock>&)`]
 
     template <class Lock>
     T& get(nested_strict_lock<Lock>& lk);
@@ -2684,7 +2684,7 @@ Only the specificities respect to __Lockable are described here.
 [endsect]
 
 [///////////////////////////////]
-[section:get3 `get(strict_lock<nested_strict_lock<Lock>>&)`]
+[section:get3 `get(Lock&)`]
 
     template <class Lock>
     T& get(Lock& lk);
@@ -2826,7 +2826,7 @@ Only the specificities respect to __Lockable are described here.
 
 [endsect]
 [///////////////////////////////]
-[section:get2 `get(strict_lock<nested_strict_lock<Lock>>&)`]
+[section:get2 `get(nested_strict_lock<Lock>&)`]
 
     template <class Lock>
     T& get(nested_strict_lock<Lock>& lk);
@@ -2846,7 +2846,7 @@ Only the specificities respect to __Lockable are described here.
 [endsect]
 
 [///////////////////////////////]
-[section:get3 `get(strict_lock<nested_strict_lock<Lock>>&)`]
+[section:get3 `get(Lock&)`]
 
     template <class Lock>
     T& get(Lock& lk);

doc/sync_queues_ref.qbk

@@ -181,7 +181,7 @@ where
 
 [variablelist
 
-[[Requires:] [Q::value_type is no throw copy movable. This is needed to ensure the exception safety.]]
+[[Requires:] [Q::value_type is no throw move constructible. This is needed to ensure the exception safety.]]
 
 [[Effects:] [Waits until the queue is not empty and not closed. If the queue is empty and closed throws sync_queue_is_closed. Otherwise pull the element from the queue `q` and moves the pulled element.]]
 
@@ -206,7 +206,7 @@ where
 
 [variablelist
 
-[/[Requires:] [Q::value_type is no throw copy movable. This is needed to ensure the exception safety. ]]
+[/[Requires:] [Q::value_type is no throw move assignable. This is needed to ensure the exception safety. ]]
 
 [[Effects:] [Waits until the queue is not empty and not closed. If the queue is empty and closed throws sync_queue_is_closed. Otherwise pull the element from the queue `q` and moves the pulled element into a shared_ptr.]]
 
@@ -314,7 +314,7 @@ where
 
 [variablelist
 
-[[Effects:] [Waits until the queue is not empty and then pull the element from the queue `q` and moves the pulled element into `lve` (this could need an allocation for unbounded queues).]]
+[[Effects:] [If the queue is not empty pulls the element from the queue `q` and moves the pulled element into `lve` (this could need an allocation for unbounded queues).]]
 
 [[Synchronization:] [Prior pull-like operations on the same object synchronizes with this operation.]]
 
@@ -393,7 +393,7 @@ where
 
 [endsect]
 [/////////////////////////////////////]
-[section:nonblocking_push_back_m `s = q.nonblocking_push_back(rve());`]
+[section:nonblocking_push_back_m `s = q.nonblocking_push_back(rve);`]
 
 [variablelist
 
@@ -427,7 +427,7 @@ where
 
 [variablelist
 
-[[Effects:] [Waits until the queue is not empty and then pull the element from the queue `q` and moves the pulled element into `lve` (this could need an allocation for unbounded queues).]]
+[[Effects:] [If the queue is not empty pulls the element from the queue `q` and moves the pulled element into `lve` (this could need an allocation for unbounded queues).]]
 
 [[Synchronization:] [Prior pull-like operations on the same object synchronizes with this operation.]]
 
@@ -636,12 +636,12 @@ Closed queues add the following valid expressions
 
   namespace boost
   {
-    template <typename ValueType>
+    template <typename ValueType, class SizeType=std::size_t>
     class queue_base
     {
     public:
       typedef ValueType value_type;
-      typedef std::size_t size_type;
+      typedef SizeType size_type;
   
       // Constructors/Assignment/Destructors
       virtual ~queue_base() {};
@@ -671,7 +671,7 @@ Closed queues add the following valid expressions
   
       virtual queue_op_status wait_push_back(const value_type& x) = 0;
       virtual queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
-      virtual queue_op_status wait_pull_front(ValueType& elem) = 0;
+      virtual queue_op_status wait_pull_front(value_type& elem) = 0;
   
     };
   }
@@ -685,11 +685,11 @@ Closed queues add the following valid expressions
   namespace boost
   {
     template <typename Queue>
-    class queue_adaptor : public queue_base<typename Queue::value_type>
+    class queue_adaptor : public queue_base<typename Queue::value_type, typename Queue::size_type>
     {
     public:
       typedef typename Queue::value_type value_type;
-      typedef std::size_t size_type;
+      typedef typename Queue::size_type size_type;
   
       // Constructors/Assignment/Destructors
   
@@ -1002,13 +1002,13 @@ Closed queues add the following valid expressions
 
   namespace boost
   {
-    template <typename ValueType>
+    template <typename ValueType, class Container = csbl::devector<ValueType>>
     class sync_queue
     {
     public:
       typedef ValueType value_type;
-      typedef csbl::deque<ValueType> underlying_queue_type;
+      typedef Container underlying_queue_type;
-      typedef std::size_t size_type;
+      typedef typename Container::size_type size_type;
 
       sync_queue(sync_queue const&) = delete;
       sync_queue& operator=(sync_queue const&) = delete;

doc/synchronized_value_ref.qbk

@@ -88,9 +88,9 @@
       typedef T value_type;
       typedef Lockable mutex_type;
 
-      synchronized_value() noexept(is_nothrow_default_constructible<T>::value);
+      synchronized_value() noexcept(is_nothrow_default_constructible<T>::value);
-      synchronized_value(T const& other) noexept(is_nothrow_copy_constructible<T>::value);
+      synchronized_value(T const& other) noexcept(is_nothrow_copy_constructible<T>::value);
-      synchronized_value(T&& other) noexept(is_nothrow_move_constructible<T>::value);
+      synchronized_value(T&& other) noexcept(is_nothrow_move_constructible<T>::value);
       synchronized_value(synchronized_value const& rhs);
       synchronized_value(synchronized_value&& other);
 
@@ -129,7 +129,7 @@
 
 [section:constructor `synchronized_value()`]
 
-      synchronized_value() noexept(is_nothrow_default_constructible<T>::value);
+      synchronized_value() noexcept(is_nothrow_default_constructible<T>::value);
 
 [variablelist
 
@@ -145,7 +145,7 @@
 
 [section:constructor_vt `synchronized_value(T const&)`]
 
-      synchronized_value(T const& other) noexept(is_nothrow_copy_constructible<T>::value);
+      synchronized_value(T const& other) noexcept(is_nothrow_copy_constructible<T>::value);
 
 [variablelist
 
@@ -175,11 +175,11 @@
 
 [section:move_vt `synchronized_value(T&&)`]
 
-      synchronized_value(T&& other) noexept(is_nothrow_move_constructible<T>::value);
+      synchronized_value(T&& other) noexcept(is_nothrow_move_constructible<T>::value);
 
 [variablelist
 
-[[Requires:] [`T` is `CopyMovable `.]]
+[[Requires:] [`T` is `MoveConstructible `.]]
 [[Effects:] [Move constructs the cloaked value_type]]
 
 [[Throws:] [Any exception thrown by `value_type(value_type&&)`.]]
@@ -194,7 +194,7 @@
 
 [variablelist
 
-[[Requires:] [`T` is `CopyMovable `.]]
+[[Requires:] [`T` is `MoveConstructible `.]]
 [[Effects:] [Move constructs the cloaked value_type]]
 
 [[Throws:] [Any exception thrown by `value_type(value_type&&)` or `mtx_.lock()`.]]
@@ -209,7 +209,7 @@
 
 [variablelist
 
-[[Requires:] [`T` is `Assignale`.]]
+[[Requires:] [`T` is `Assignable`.]]
 [[Effects:] [Copies the underlying value on a scope protected by the two mutexes. The mutex is not copied. The locks are acquired avoiding deadlock. For example, there is no problem if one thread assigns `a = b` and the other assigns `b = a`.]]
 [[Return:] [`*this`]]
 
@@ -224,7 +224,7 @@
 
 [variablelist
 
-[[Requires:] [`T` is `Assignale`.]]
+[[Requires:] [`T` is `Assignable`.]]
 [[Effects:] [Copies the value on a scope protected by the mutex.]]
 [[Return:] [`*this`]]
 
@@ -273,7 +273,7 @@
 
 [variablelist
 
-[[Requires:] [`T` is `Assignale`.]]
+[[Requires:] [`T` is `Assignable`.]]
 [[Effects:] [Swaps the data on a scope protected by both mutex. Both mutex are acquired to avoid dead-lock. The mutexes are not swapped.]]
 
 [[Throws:] [Any exception thrown by `swap(value_, rhs.value)` or `mtx_.lock()` or `rhs_.mtx_.lock()`.]]

doc/thread.qbk

@@ -8,10 +8,10 @@
 
 [library Thread
     [quickbook 1.5]
-    [version 4.4.0]
+    [version 4.5.0]
     [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
     [copyright 2007-11 Anthony Williams]
-    [copyright 2011-14 Vicente J. Botet Escriba]
+    [copyright 2011-15 Vicente J. Botet Escriba]
     [purpose C++ Library for launching threads and synchronizing data between them]
     [category text]
     [license

example/default_executor.cpp

@@ -0,0 +1,61 @@
+// 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/generic_executor_ref.hpp>
+#include <string>
+#include <iostream>
+
+#include <boost/thread/caller_context.hpp>
+
+
+boost::generic_executor_ref default_executor()
+{
+  static boost::basic_thread_pool tp(4);
+  return boost::generic_executor_ref(tp);
+}
+
+void p2()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
+  std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+
+void p1()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
+  default_executor().submit(&p2);
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(400));
+  std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+int main()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+
+  default_executor().submit(&p1);
+
+  boost::this_thread::sleep_for(boost::chrono::seconds(5));
+
+  std::cout << BOOST_CONTEXTOF << std::endl;
+
+  return 1;
+
+}

example/this_executor.cpp

@@ -0,0 +1,86 @@
+// 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_THREAD_ID
+
+#include <boost/thread/caller_context.hpp>
+#include <boost/thread/executors/basic_thread_pool.hpp>
+#include <boost/thread/executors/generic_executor_ref.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <string>
+#include <iostream>
+
+#include <boost/thread/caller_context.hpp>
+
+struct current_executor_state_type {
+  boost::shared_ptr<boost::generic_executor_ref> current_executor_ptr;
+
+  template <class Executor>
+  void set_current_executor(Executor& ex)
+  {
+    current_executor_ptr = boost::make_shared<boost::generic_executor_ref>(ex);
+  }
+  boost::generic_executor_ref current_executor()
+  {
+    if (current_executor_ptr)
+      return *current_executor_ptr;
+    else
+      throw "";
+  }
+};
+
+thread_local current_executor_state_type current_executor_state;
+
+boost::generic_executor_ref current_executor()
+{
+  return current_executor_state.current_executor();
+}
+
+void p2()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
+  std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+
+void p1()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
+  current_executor().submit(&p2);
+  boost::this_thread::sleep_for(boost::chrono::milliseconds(400));
+  std::cout << BOOST_CONTEXTOF << std::endl;
+}
+
+int main()
+{
+  std::cout << BOOST_CONTEXTOF << std::endl;
+
+  boost::basic_thread_pool tp(4,
+      // at_thread_entry
+      [](boost::basic_thread_pool& pool)
+      {
+        current_executor_state.set_current_executor(pool);
+      }
+  );
+
+  tp.submit(&p1);
+
+  boost::this_thread::sleep_for(boost::chrono::seconds(5));
+
+  std::cout << BOOST_CONTEXTOF << std::endl;
+
+  return 1;
+
+}

include/boost/thread/caller_context.hpp

@@ -1,4 +1,4 @@
-// (C) Copyright 2013 Vicente J. Botet Escriba
+// (C) Copyright 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)
@@ -12,6 +12,7 @@
 #include <boost/thread/thread.hpp>
 #endif
 #include <boost/current_function.hpp>
+#include <boost/io/ios_state.hpp>
 #include <iomanip>
 
 #include <boost/config/abi_prefix.hpp>
@@ -43,9 +44,11 @@ namespace boost
 #endif
     {
       io::ios_flags_saver ifs(os);
-      os << ctx.filename << "["
+      os << std::setw(50) << ctx.filename << "["
          << std::setw(4) << std::right << std::dec<< ctx.lineno << "] ";
+#if defined BOOST_THREAD_USES_LOG_CURRENT_FUNCTION
       os << ctx.func << " " ;
+#endif
     }
     return os;
   }

include/boost/thread/concurrent_queues/deque_adaptor.hpp

@@ -27,12 +27,12 @@ namespace detail
 
   template <typename Queue>
   class deque_adaptor_copyable_only :
-    public boost::deque_base<typename Queue::value_type>
+    public boost::deque_base<typename Queue::value_type, typename Queue::size_type>
   {
       Queue queue;
   public:
     typedef typename Queue::value_type value_type;
-    typedef std::size_t size_type;
+    typedef typename Queue::size_type size_type;
 
     // Constructors/Assignment/Destructors
     deque_adaptor_copyable_only()  {}
@@ -63,12 +63,12 @@ namespace detail
   };
   template <typename Queue>
   class deque_adaptor_movable_only :
-    public boost::deque_base<typename Queue::value_type>
+    public boost::deque_base<typename Queue::value_type, typename Queue::size_type>
   {
       Queue queue;
   public:
     typedef typename Queue::value_type value_type;
-    typedef std::size_t size_type;
+    typedef typename Queue::size_type size_type;
 
     // Constructors/Assignment/Destructors
 
@@ -102,12 +102,12 @@ namespace detail
 
   template <typename Queue>
   class deque_adaptor_copyable_and_movable :
-    public boost::deque_base<typename Queue::value_type>
+    public boost::deque_base<typename Queue::value_type, typename Queue::size_type>
   {
       Queue queue;
   public:
     typedef typename Queue::value_type value_type;
-    typedef std::size_t size_type;
+    typedef typename Queue::size_type size_type;
 
     // Constructors/Assignment/Destructors
 
@@ -195,7 +195,7 @@ namespace detail
   {
   public:
       typedef typename Queue::value_type value_type;
-      typedef std::size_t size_type;
+      typedef typename Queue::size_type size_type;
     // Constructors/Assignment/Destructors
     virtual ~deque_adaptor() {};
   };

include/boost/thread/concurrent_queues/deque_base.hpp

@@ -27,12 +27,12 @@ namespace concurrent
 namespace detail
 {
 
-  template <typename ValueType>
+  template <typename ValueType, class SizeType>
   class deque_base_copyable_only
   {
   public:
     typedef ValueType value_type;
-    typedef std::size_t size_type;
+    typedef SizeType size_type;
 
     // Constructors/Assignment/Destructors
     virtual ~deque_base_copyable_only() {};
@@ -58,16 +58,16 @@ namespace detail
     virtual queue_op_status nonblocking_pull_front(value_type&) = 0;
 
     virtual queue_op_status wait_push_back(const value_type& x) = 0;
-    virtual queue_op_status wait_pull_front(ValueType& elem) = 0;
+    virtual queue_op_status wait_pull_front(value_type& elem) = 0;
 
   };
 
-  template <typename ValueType>
+  template <typename ValueType, class SizeType>
   class deque_base_movable_only
   {
   public:
     typedef ValueType value_type;
-    typedef std::size_t size_type;
+    typedef SizeType size_type;
     // Constructors/Assignment/Destructors
     virtual ~deque_base_movable_only() {};
 
@@ -88,7 +88,7 @@ namespace detail
 
     virtual queue_op_status nonblocking_pull_front(value_type&) = 0;
 
-    virtual queue_op_status wait_pull_front(ValueType& elem) = 0;
+    virtual queue_op_status wait_pull_front(value_type& elem) = 0;
 
     virtual void push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
     virtual queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
@@ -97,12 +97,12 @@ namespace detail
   };
 
 
-  template <typename ValueType>
+  template <typename ValueType, class SizeType>
   class deque_base_copyable_and_movable
   {
   public:
     typedef ValueType value_type;
-    typedef std::size_t size_type;
+    typedef SizeType size_type;
     // Constructors/Assignment/Destructors
     virtual ~deque_base_copyable_and_movable() {};
 
@@ -129,7 +129,7 @@ namespace detail
     virtual queue_op_status nonblocking_pull_front(value_type&) = 0;
 
     virtual queue_op_status wait_push_back(const value_type& x) = 0;
-    virtual queue_op_status wait_pull_front(ValueType& elem) = 0;
+    virtual queue_op_status wait_pull_front(value_type& elem) = 0;
 
     virtual void push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
     virtual queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
@@ -137,7 +137,7 @@ namespace detail
     virtual queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
   };
 
-  template <class T,
+  template <class T, class ST,
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if defined __GNUC__ && ! defined __clang__
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
@@ -166,28 +166,28 @@ namespace detail
       >
   struct deque_base;
 
-  template <class T>
+  template <class T, class ST>
-  struct deque_base<T, true, true> {
+  struct deque_base<T, ST, true, true> {
-    typedef deque_base_copyable_and_movable<T> type;
+    typedef deque_base_copyable_and_movable<T, ST> type;
   };
-  template <class T>
+  template <class T, class ST>
-  struct deque_base<T, true, false> {
+  struct deque_base<T, ST, true, false> {
-    typedef deque_base_copyable_only<T> type;
+    typedef deque_base_copyable_only<T, ST> type;
   };
-  template <class T>
+  template <class T, class ST>
-  struct deque_base<T, false, true> {
+  struct deque_base<T, ST, false, true> {
-    typedef deque_base_movable_only<T> type;
+    typedef deque_base_movable_only<T, ST> type;
   };
 
 }
 
-  template <typename ValueType>
+  template <class ValueType, class SizeType=std::size_t>
   class deque_base :
-    public detail::deque_base<ValueType>::type
+    public detail::deque_base<ValueType, SizeType>::type
   {
   public:
       typedef ValueType value_type;
-      typedef std::size_t size_type;
+      typedef SizeType size_type;
     // Constructors/Assignment/Destructors
     virtual ~deque_base() {};
   };

include/boost/thread/concurrent_queues/detail/sync_deque_base.hpp

@@ -37,7 +37,7 @@ namespace detail
   public:
     typedef ValueType value_type;
     typedef Queue underlying_queue_type;
-    typedef std::size_t size_type;
+    typedef typename Queue::size_type size_type;
     typedef queue_op_status op_status;
 
     typedef typename chrono::steady_clock clock;

include/boost/thread/concurrent_queues/detail/sync_queue_base.hpp

@@ -37,7 +37,7 @@ namespace detail
   public:
     typedef ValueType value_type;
     typedef Queue underlying_queue_type;
-    typedef std::size_t size_type;
+    typedef typename Queue::size_type size_type;
     typedef queue_op_status op_status;
 
     typedef typename chrono::steady_clock clock;

include/boost/thread/concurrent_queues/queue_adaptor.hpp

@@ -27,12 +27,12 @@ namespace detail
 
   template <typename Queue>
   class queue_adaptor_copyable_only :
-    public boost::queue_base<typename Queue::value_type>
+    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
   {
       Queue queue;
   public:
     typedef typename Queue::value_type value_type;
-    typedef std::size_t size_type;
+    typedef typename Queue::size_type size_type;
 
     // Constructors/Assignment/Destructors
     queue_adaptor_copyable_only()  {}
@@ -63,12 +63,12 @@ namespace detail
   };
   template <typename Queue>
   class queue_adaptor_movable_only :
-    public boost::queue_base<typename Queue::value_type>
+    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
   {
       Queue queue;
   public:
     typedef typename Queue::value_type value_type;
-    typedef std::size_t size_type;
+    typedef typename Queue::size_type size_type;
 
     // Constructors/Assignment/Destructors
 
@@ -102,12 +102,12 @@ namespace detail
 
   template <typename Queue>
   class queue_adaptor_copyable_and_movable :
-    public boost::queue_base<typename Queue::value_type>
+    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
   {
       Queue queue;
   public:
     typedef typename Queue::value_type value_type;
-    typedef std::size_t size_type;
+    typedef typename Queue::size_type size_type;
 
     // Constructors/Assignment/Destructors
 
@@ -195,7 +195,7 @@ namespace detail
   {
   public:
       typedef typename Queue::value_type value_type;
-      typedef std::size_t size_type;
+      typedef typename Queue::size_type size_type;
     // Constructors/Assignment/Destructors
     virtual ~queue_adaptor() {};
   };

include/boost/thread/concurrent_queues/queue_base.hpp

@@ -27,12 +27,12 @@ namespace concurrent
 namespace detail
 {
 
-  template <typename ValueType>
+  template <typename ValueType, class SizeType>
   class queue_base_copyable_only
   {
   public:
     typedef ValueType value_type;
-    typedef std::size_t size_type;
+    typedef SizeType size_type;
 
     // Constructors/Assignment/Destructors
     virtual ~queue_base_copyable_only() {};
@@ -62,12 +62,12 @@ namespace detail
 
   };
 
-  template <typename ValueType>
+  template <typename ValueType, class SizeType>
   class queue_base_movable_only
   {
   public:
     typedef ValueType value_type;
-    typedef std::size_t size_type;
+    typedef SizeType size_type;
     // Constructors/Assignment/Destructors
     virtual ~queue_base_movable_only() {};
 
@@ -88,7 +88,7 @@ namespace detail
 
     virtual queue_op_status nonblocking_pull(value_type&) = 0;
 
-    virtual queue_op_status wait_pull(ValueType& elem) = 0;
+    virtual queue_op_status wait_pull(value_type& elem) = 0;
 
     virtual void push(BOOST_THREAD_RV_REF(value_type) x) = 0;
     virtual queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
@@ -97,12 +97,12 @@ namespace detail
   };
 
 
-  template <typename ValueType>
+  template <typename ValueType, class SizeType>
   class queue_base_copyable_and_movable
   {
   public:
     typedef ValueType value_type;
-    typedef std::size_t size_type;
+    typedef SizeType size_type;
     // Constructors/Assignment/Destructors
     virtual ~queue_base_copyable_and_movable() {};
 
@@ -129,7 +129,7 @@ namespace detail
     virtual queue_op_status nonblocking_pull(value_type&) = 0;
 
     virtual queue_op_status wait_push(const value_type& x) = 0;
-    virtual queue_op_status wait_pull(ValueType& elem) = 0;
+    virtual queue_op_status wait_pull(value_type& elem) = 0;
 
     virtual void push(BOOST_THREAD_RV_REF(value_type) x) = 0;
     virtual queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
@@ -137,7 +137,7 @@ namespace detail
     virtual queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
   };
 
-  template <class T,
+  template <class T, class ST,
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if defined __GNUC__ && ! defined __clang__
 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
@@ -166,28 +166,28 @@ namespace detail
       >
   struct queue_base;
 
-  template <class T>
+  template <class T, class ST>
-  struct queue_base<T, true, true> {
+  struct queue_base<T, ST, true, true> {
-    typedef queue_base_copyable_and_movable<T> type;
+    typedef queue_base_copyable_and_movable<T, ST> type;
   };
-  template <class T>
+  template <class T, class ST>
-  struct queue_base<T, true, false> {
+  struct queue_base<T, ST, true, false> {
-    typedef queue_base_copyable_only<T> type;
+    typedef queue_base_copyable_only<T, ST> type;
   };
-  template <class T>
+  template <class T, class ST>
-  struct queue_base<T, false, true> {
+  struct queue_base<T, ST, false, true> {
-    typedef queue_base_movable_only<T> type;
+    typedef queue_base_movable_only<T, ST> type;
   };
 
 }
 
-  template <typename ValueType>
+  template <typename ValueType, class SizeType=std::size_t>
   class queue_base :
-    public detail::queue_base<ValueType>::type
+    public detail::queue_base<ValueType, SizeType>::type
   {
   public:
       typedef ValueType value_type;
-      typedef std::size_t size_type;
+      typedef SizeType size_type;
     // Constructors/Assignment/Destructors
     virtual ~queue_base() {};
   };

include/boost/thread/concurrent_queues/sync_priority_queue.hpp

@@ -43,12 +43,13 @@ namespace detail {
       Compare _compare;
   public:
       typedef Type value_type;
+      typedef typename Container::size_type size_type;
 
       explicit priority_queue(const Compare& compare = Compare())
           : _elements(), _compare(compare)
       { }
 
-      std::size_t size() const
+      size_type size() const
       {
           return _elements.size();
       }

include/boost/thread/concurrent_queues/sync_timed_queue.hpp

@@ -106,6 +106,11 @@ namespace detail
     template <class Rep, class Period>
     void push(const T& elem, chrono::duration<Rep,Period> const& dura);
 
+    template <class Duration>
+    void push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp);
+    template <class Rep, class Period>
+    void push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura);
+
     template <class Duration>
     queue_op_status try_push(const T& elem, chrono::time_point<clock,Duration> const& tp);
     template <class Rep, class Period>
@@ -158,6 +163,22 @@ namespace detail
     push(elem, clock::now() + dura);
   }
 
+  template <class T, class Clock>
+  template <class Duration>
+  void sync_timed_queue<T, Clock>::push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
+  {
+    super::push(stype(boost::move(elem),tp));
+  }
+
+  template <class T, class Clock>
+  template <class Rep, class Period>
+  void sync_timed_queue<T, Clock>::push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
+  {
+    push(boost::move(elem), clock::now() + dura);
+  }
+
+
+
   template <class T, class Clock>
   template <class Duration>
   queue_op_status sync_timed_queue<T, Clock>::try_push(const T& elem, chrono::time_point<clock,Duration> const& tp)

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

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

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

@@ -1,5 +1,5 @@
 // Copyright (C) 2014 Ian Forbed
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-2015 Vicente J. Botet Escriba
 //
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,8 @@
 #include <boost/atomic.hpp>
 #include <boost/function.hpp>
 
+#include <boost/config/abi_prefix.hpp>
+
 namespace boost
 {
 namespace executors
@@ -23,11 +25,10 @@ namespace executors
 namespace detail
 {
   template <class Clock=chrono::steady_clock>
-  class scheduled_executor_base : public priority_executor_base<concurrent::sync_timed_queue<boost::function<void()>, Clock  > >
+  class scheduled_executor_base : public priority_executor_base<concurrent::sync_timed_queue<executors::work_pq, Clock  > >
   {
   public:
-    typedef boost::function<void()> work;
+    typedef executors::work_pq work;
-    //typedef executors::work work;
     typedef Clock clock;
     typedef typename clock::duration duration;
     typedef typename clock::time_point time_point;
@@ -46,12 +47,12 @@ namespace detail
 
     void submit_at(work w, const time_point& tp)
     {
-      this->_workq.push(w, tp);
+      this->_workq.push(boost::move(w), tp);
     }
 
     void submit_after(work w, const duration& dura)
     {
-      this->_workq.push(w, dura+clock::now());
+      this->_workq.push(boost::move(w), dura+clock::now());
     }
 
   }; //end class
@@ -59,4 +60,7 @@ namespace detail
 } //end detail namespace
 } //end executors namespace
 } //end boost namespace
+
+#include <boost/config/abi_suffix.hpp>
+
 #endif

include/boost/thread/executors/work.hpp

@@ -8,36 +8,23 @@
 #define BOOST_THREAD_EXECUTORS_WORK_HPP
 
 #include <boost/thread/detail/config.hpp>
-
-#if ! defined BOOST_THREAD_EXECUTORS_WORK_ACCEPTS_MOVABLE \
- && ! defined BOOST_THREAD_EXECUTORS_WORK_DONT_ACCEPT_MOVABLE
-#define BOOST_THREAD_EXECUTORS_WORK_ACCEPTS_MOVABLE
-//#define BOOST_THREAD_EXECUTORS_WORK_DONT_ACCEPT_MOVABLE
-#endif
-
-#if defined BOOST_THREAD_EXECUTORS_WORK_ACCEPTS_MOVABLE
-
 #include <boost/thread/detail/nullary_function.hpp>
-
-namespace boost
-{
-  namespace executors
-  {
-    typedef detail::nullary_function<void()> work;
-  }
-} // namespace boost
-
-#else
 #include <boost/thread/csbl/functional.hpp>
 
 namespace boost
 {
   namespace executors
   {
-    typedef csbl::function<void()> work;
+    typedef detail::nullary_function<void()> work;
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    typedef detail::nullary_function<void()> work_pq;
+    //typedef csbl::function<void()> work_pq;
+#else
+    typedef csbl::function<void()> work_pq;
+#endif
   }
 } // namespace boost
 
-#endif
 
 #endif //  BOOST_THREAD_EXECUTORS_WORK_HPP

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

@@ -3,7 +3,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Vicente J. Botet Escriba 2014. Distributed under the Boost
+// (C) Copyright Vicente J. Botet Escriba 2014-2015. 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)
 //
@@ -50,12 +50,13 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)
     void handle_task_region_exceptions(exception_list& errors)
     {
       try {
-        boost::rethrow_exception(boost::current_exception());
+        throw;
-        //throw boost::current_exception();
       }
+#if defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED
       catch (task_canceled_exception& ex)
       {
       }
+#endif
       catch (exception_list const& el)
       {
         for (exception_list::const_iterator it = el.begin(); it != el.end(); ++it)
@@ -94,7 +95,7 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)
         {
           lock_guard<mutex> lk(tr.mtx);
           tr.canceled = true;
-          handle_task_region_exceptions(tr.exs);
+          throw;
         }
       }
     };
@@ -123,8 +124,6 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)
     {
       wait_for_all(group.begin(), group.end());
 
-      #if ! defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED
-
       for (group_type::iterator it = group.begin(); it != group.end(); ++it)
       {
         future<void>& f = *it;
@@ -140,11 +139,9 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)
           }
         }
       }
-      #endif
       if (exs.size() != 0)
       {
         boost::throw_exception(exs);
-        //throw exs;
       }
     }
 protected:
@@ -187,6 +184,7 @@ protected:
     }
 
 #if defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED
+    mutable mutex mtx;
     bool canceled;
 #endif
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
@@ -195,8 +193,6 @@ protected:
     exception_list exs;
     typedef csbl::vector<future<void> > group_type;
     group_type group;
-    mutable mutex mtx;
-
 
   public:
     BOOST_DELETED_FUNCTION(task_region_handle_gen(const task_region_handle_gen&))
@@ -207,11 +203,12 @@ protected:
     template<typename F>
     void run(BOOST_THREAD_FWD_REF(F) f)
     {
-      lock_guard<mutex> lk(mtx);
 #if defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED
-      if (canceled) {
+      {
-        boost::throw_exception(task_canceled_exception());
+        lock_guard<mutex> lk(mtx);
-        //throw task_canceled_exception();
+        if (canceled) {
+          boost::throw_exception(task_canceled_exception());
+        }
       }
 #if defined BOOST_THREAD_PROVIDES_EXECUTORS
       group.push_back(async(*ex, detail::wrapped<task_region_handle_gen<Executor>, F>(*this, forward<F>(f))));
@@ -229,11 +226,12 @@ protected:
 
     void wait()
     {
-      lock_guard<mutex> lk(mtx);
 #if defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED
-      if (canceled) {
+      {
-        boost::throw_exception(task_canceled_exception());
+        lock_guard<mutex> lk(mtx);
-        //throw task_canceled_exception{};
+        if (canceled) {
+          boost::throw_exception(task_canceled_exception());
+        }
       }
 #endif
       wait_all();
@@ -276,7 +274,6 @@ protected:
     }
     catch (...)
     {
-      lock_guard<mutex> lk(tr.mtx);
       detail::handle_task_region_exceptions(tr.exs);
     }
     tr.wait_all();
@@ -298,7 +295,6 @@ protected:
     }
     catch (...)
     {
-      lock_guard<mutex> lk(tr.mtx);
       detail::handle_task_region_exceptions(tr.exs);
     }
     tr.wait_all();

include/boost/thread/future.hpp

@@ -4892,7 +4892,9 @@ namespace detail
   make_future_unwrap_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f) {
     shared_ptr<future_unwrap_shared_state<F, Rp> >
         h(new future_unwrap_shared_state<F, Rp>(boost::move(f)));
+    lock.lock();
     h->parent.future_->set_continuation_ptr(h, lock);
+    lock.unlock();
     return BOOST_THREAD_FUTURE<Rp>(h);
   }
 }
@@ -4907,6 +4909,7 @@ namespace detail
   {
     BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
     boost::unique_lock<boost::mutex> lock(this->future_->mutex);
+    lock.unlock();
     return boost::detail::make_future_unwrap_shared_state<BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >, R2>(lock, boost::move(*this));
   }
 #endif

include/boost/thread/pthread/mutex.hpp

@@ -1,12 +1,13 @@
 #ifndef BOOST_THREAD_PTHREAD_MUTEX_HPP
 #define BOOST_THREAD_PTHREAD_MUTEX_HPP
 // (C) Copyright 2007-8 Anthony Williams
-// (C) Copyright 2011-2012 Vicente J. Botet Escriba
+// (C) Copyright 2011,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)
 
 #include <boost/thread/detail/config.hpp>
+#include <boost/assert.hpp>
 #include <pthread.h>
 #include <boost/throw_exception.hpp>
 #include <boost/core/ignore_unused.hpp>
@@ -26,13 +27,12 @@
 #endif
 #include <boost/thread/detail/delete.hpp>
 
-#ifdef _POSIX_TIMEOUTS
+#if (defined(_POSIX_TIMEOUTS) && (_POSIX_TIMEOUTS-0)>=200112L) \
-#if _POSIX_TIMEOUTS >= 0 && _POSIX_TIMEOUTS>=200112L
+ || (defined(__ANDROID__) && defined(__ANDROID_API__) && __ANDROID_API__ >= 21)
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
 #define BOOST_PTHREAD_HAS_TIMEDLOCK
 #endif
 #endif
-#endif
 
 
 #include <boost/config/abi_prefix.hpp>
@@ -123,10 +123,12 @@ namespace boost
         void unlock()
         {
             int res = posix::pthread_mutex_unlock(&m);
-            if (res)
+            (void)res;
-            {
+            BOOST_ASSERT(res == 0);
-                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
+//            if (res)
-            }
+//            {
+//                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
+//            }
         }
 
         bool try_lock()
@@ -219,10 +221,12 @@ namespace boost
         void unlock()
         {
             int res = posix::pthread_mutex_unlock(&m);
-            if (res)
+            (void)res;
-            {
+            BOOST_ASSERT(res == 0);
-                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
+//            if (res)
-            }
+//            {
+//                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
+//            }
         }
 
         bool try_lock()

include/boost/thread/pthread/recursive_mutex.hpp

@@ -27,16 +27,19 @@
 #endif
 #include <boost/thread/detail/delete.hpp>
 
-#ifdef _POSIX_TIMEOUTS
+#if (defined _POSIX_TIMEOUTS && (_POSIX_TIMEOUTS-0)>=200112L) \
-#if _POSIX_TIMEOUTS >= 0 && _POSIX_TIMEOUTS>=200112L
+ || (defined __ANDROID__ && defined __ANDROID_API__ && __ANDROID_API__ >= 21)
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
 #define BOOST_PTHREAD_HAS_TIMEDLOCK
 #endif
 #endif
+
+#if  defined BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE \
+ ||  defined __ANDROID__
+#define BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
 #endif
 
-
+#if defined BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE && defined BOOST_PTHREAD_HAS_TIMEDLOCK
-#if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE) && defined(BOOST_PTHREAD_HAS_TIMEDLOCK)
 #define BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
 #endif
 
@@ -48,7 +51,7 @@ namespace boost
     {
     private:
         pthread_mutex_t m;
-#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#ifndef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
         pthread_cond_t cond;
         bool is_locked;
         pthread_t owner;
@@ -58,7 +61,7 @@ namespace boost
         BOOST_THREAD_NO_COPYABLE(recursive_mutex)
         recursive_mutex()
         {
-#ifdef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#ifdef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
             pthread_mutexattr_t attr;
 
             int const init_attr_res=pthread_mutexattr_init(&attr);
@@ -99,12 +102,12 @@ namespace boost
         ~recursive_mutex()
         {
             BOOST_VERIFY(!pthread_mutex_destroy(&m));
-#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#ifndef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
             BOOST_VERIFY(!pthread_cond_destroy(&cond));
 #endif
         }
 
-#ifdef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#ifdef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
         void lock()
         {
             BOOST_VERIFY(!pthread_mutex_lock(&m));

include/boost/thread/pthread/thread_data.hpp

@@ -115,8 +115,13 @@ namespace boost
             boost::detail::thread_exit_callback_node* thread_exit_callbacks;
             std::map<void const*,boost::detail::tss_data_node> tss_data;
 
+//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            // These data must be at the end so that the access to the other fields doesn't change
+            // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined.
+            // Another option is to have them always
             pthread_mutex_t* cond_mutex;
             pthread_cond_t* current_cond;
+//#endif
             typedef std::vector<std::pair<condition_variable*, mutex*>
             //, hidden_allocator<std::pair<condition_variable*, mutex*> >
             > notify_list_t;
@@ -136,8 +141,10 @@ namespace boost
                 thread_handle(0),
                 done(false),join_started(false),joined(false),
                 thread_exit_callbacks(0),
+//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 cond_mutex(0),
                 current_cond(0),
+//#endif
                 notify(),
                 async_states_()
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS

src/pthread/thread.cpp

@@ -96,13 +96,10 @@ namespace boost
                                 }
                                 delete current_node;
                             }
-                            for(std::map<void const*,tss_data_node>::iterator next=thread_info->tss_data.begin(),
+                            while (!thread_info->tss_data.empty())
-                                    current,
-                                    end=thread_info->tss_data.end();
-                                next!=end;)
                             {
-                                current=next;
+                                std::map<void const*,detail::tss_data_node>::iterator current
-                                ++next;
+                                    = thread_info->tss_data.begin();
                                 if(current->second.func && (current->second.value!=0))
                                 {
                                     (*current->second.func)(current->second.value);
@@ -162,7 +159,7 @@ namespace boost
             static void* thread_proxy(void* param)
             {
                 boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->self;
-                thread_info->self.reset();
+                //thread_info->self.reset();
                 detail::set_current_thread_data(thread_info.get());
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 BOOST_TRY

src/win32/thread.cpp

@@ -44,7 +44,7 @@
 #include <wrl\ftm.h>
 #include <windows.system.threading.h>
 #pragma comment(lib, "runtimeobject.lib")
-#endif 
+#endif
 
 namespace boost
 {
@@ -198,7 +198,7 @@ namespace boost
     namespace detail
     {
         std::atomic_uint threadCount;
-        
+
         bool win32::scoped_winrt_thread::start(thread_func address, void *parameter, unsigned int *thrdId)
         {
             Microsoft::WRL::ComPtr<ABI::Windows::System::Threading::IThreadPoolStatics> threadPoolFactory;
@@ -220,7 +220,7 @@ namespace boost
             m_completionHandle = completionHandle;
 
             // Create new work item.
-            Microsoft::WRL::ComPtr<ABI::Windows::System::Threading::IWorkItemHandler> workItem = 
+            Microsoft::WRL::ComPtr<ABI::Windows::System::Threading::IWorkItemHandler> workItem =
                 Microsoft::WRL::Callback<Microsoft::WRL::Implements<Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, ABI::Windows::System::Threading::IWorkItemHandler, Microsoft::WRL::FtmBase>>
                 ([address, parameter, completionHandle](ABI::Windows::Foundation::IAsyncAction *)
             {
@@ -274,13 +274,10 @@ namespace boost
                         }
                         boost::detail::heap_delete(current_node);
                     }
-                    for(std::map<void const*,detail::tss_data_node>::iterator next=current_thread_data->tss_data.begin(),
+                    while (!current_thread_data->tss_data.empty())
-                            current,
-                            end=current_thread_data->tss_data.end();
-                        next!=end;)
                     {
-                        current=next;
+                        std::map<void const*,detail::tss_data_node>::iterator current
-                        ++next;
+                            = current_thread_data->tss_data.begin();
                         if(current->second.func && (current->second.value!=0))
                         {
                             (*current->second.func)(current->second.value);
@@ -346,7 +343,7 @@ namespace boost
         return true;
 #endif
     }
-    
+
     bool thread::start_thread_noexcept(const attributes& attr)
     {
 #if BOOST_PLAT_WINDOWS_RUNTIME
@@ -367,7 +364,7 @@ namespace boost
       return true;
 #endif
     }
-    
+
     thread::thread(detail::thread_data_ptr data):
         thread_info(data)
     {}

test/Jamfile.v2

@@ -297,6 +297,7 @@ rule thread-compile ( sources : reqs * : name )
           [ thread-run test_9856.cpp ]
           [ thread-compile test_10963.cpp : : test_10963_c ]
           [ thread-run test_10964.cpp ]
+          [ thread-test test_11053.cpp ]
     ;
 
 
@@ -949,6 +950,8 @@ rule thread-compile ( sources : reqs * : name )
     explicit ts_ ;
     test-suite ts_
     :
+          [ thread-run2 ../example/this_executor.cpp : ex_this_executor ]
+          [ thread-run2 ../example/default_executor.cpp : ex_default_executor ]
     ;
 
 }

test/experimental/parallel/v2/task_region_pass.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-2015 Vicente J. Botet Escriba
 //
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -132,7 +132,9 @@ void run_exception_1()
               {
                 std::cout << "task3" << std::endl;
               });
+#if defined BOOST_THREAD_TASK_REGION_HAS_SHARED_CANCELED
           BOOST_TEST(false);
+#endif
         });
     BOOST_TEST(false);
   }

test/sync/futures/future/get_or_pass.cpp

@@ -17,6 +17,7 @@
 
 #include <boost/thread/future.hpp>
 #include <boost/thread/thread.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
 #if defined BOOST_THREAD_USES_CHRONO
@@ -128,49 +129,49 @@ int main()
           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
       }
   }
-//  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
-//  {
+  {
-//      typedef int& T;
+      typedef int& T;
-//      {
+      {
-//          boost::promise<T> p;
+          boost::promise<T> p;
-//          boost::future<T> f = p.get_future();
+          boost::future<T> f = p.get_future();
-//#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
-//          boost::thread(func3, boost::move(p)).detach();
+          boost::thread(func3, boost::move(p)).detach();
-//#else
+#else
-//          int j=5;
+          int j=5;
-//          p.set_value(j);
+          p.set_value(j);
-//#endif
+#endif
-//          BOOST_TEST(f.valid());
+          BOOST_TEST(f.valid());
-//          int k=4;
+          int k=4;
-//          BOOST_TEST(f.get_or(k) == 5);
+          BOOST_TEST(f.get_or(boost::ref(k)) == 5);
-//#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
-//          BOOST_TEST(!f.valid());
+          BOOST_TEST(!f.valid());
-//#endif
+#endif
-//      }
+      }
-//      BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+      BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
-//      {
+      {
-//          boost::promise<T> p;
+          boost::promise<T> p;
-//          boost::future<T> f = p.get_future();
+          boost::future<T> f = p.get_future();
-//#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
-//          boost::thread(func4, boost::move(p)).detach();
+          boost::thread(func4, boost::move(p)).detach();
-//#else
+#else
-//          p.set_exception(boost::make_exception_ptr(3.5));
+          p.set_exception(boost::make_exception_ptr(3.5));
-//#endif
+#endif
-//          try
+          try
-//          {
+          {
-//              BOOST_TEST(f.valid());
+              BOOST_TEST(f.valid());
-//              int j=4;
+              int j=4;
-//              BOOST_TEST(f.get_or(j) == 4);
+              BOOST_TEST(f.get_or(boost::ref(j)) == 4);
-//          }
+          }
-//          catch (...)
+          catch (...)
-//          {
+          {
-//            BOOST_TEST(false);
+            BOOST_TEST(false);
-//          }
+          }
-//#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
-//          BOOST_TEST(!f.valid());
+          BOOST_TEST(!f.valid());
-//#endif
+#endif
-//      }
+      }
-//  }
+  }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 
 

test/sync/mutual_exclusion/sync_deque/single_thread_pass.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2013 Vicente J. Botet Escriba
+// Copyright (C) 2013,2015 Vicente J. Botet Escriba
 //
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -76,7 +76,7 @@ int main()
       BOOST_TEST(! q.closed());
   }
 
-#if 0
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   {
     // empty queue push rvalue/non_copyable succeeds
       boost::sync_deque<non_copyable> q;
@@ -137,11 +137,11 @@ int main()
       BOOST_TEST(! q.closed());
   }
 
-#if 0
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   {
     // empty queue try_push rvalue/non-copyable succeeds
       boost::sync_deque<non_copyable> q;
-      BOOST_TEST(boost::queue_op_status::success ==q.try_push_back(non_copyable()));
+      BOOST_TEST(boost::queue_op_status::success ==q.try_push_back(non_copyable(1)));
       BOOST_TEST(! q.empty());
       BOOST_TEST(! q.full());
       BOOST_TEST_EQ(q.size(), 1u);
@@ -179,8 +179,7 @@ int main()
       BOOST_TEST(! q.closed());
   }
 
-
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#if 0
   {
     // empty queue nonblocking_push_back rvalue/non-copyable succeeds
       boost::sync_deque<non_copyable> q;

test/sync/mutual_exclusion/sync_pq/pq_single_thread_pass.cpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2014 Ian Forbed
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014,2015 Vicente J. Botet Escriba
 //
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -149,17 +149,15 @@ int main()
   //test_pull_until_when_not_empty();
 
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-#if 0
   {
     // empty queue try_push rvalue/non-copyable succeeds
       boost::concurrent::sync_priority_queue<non_copyable> q;
-      BOOST_TEST(boost::queue_op_status::success ==q.try_push(non_copyable()));
+      BOOST_TEST(boost::queue_op_status::success ==q.try_push(non_copyable(1)));
       BOOST_TEST(! q.empty());
       BOOST_TEST(! q.full());
       BOOST_TEST_EQ(q.size(), 1u);
       BOOST_TEST(! q.closed());
   }
-#endif
   {
     //fixme
     // empty queue try_push rvalue/non-copyable succeeds
@@ -183,17 +181,16 @@ int main()
       BOOST_TEST_EQ(q.size(), 1u);
       BOOST_TEST(! q.closed());
   }
-//  {
-//    // empty queue try_push rvalue succeeds
-//      boost::concurrent::sync_priority_queue<int> q;
-//      BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(1));
-//      BOOST_TEST(! q.empty());
-//      BOOST_TEST(! q.full());
-//      BOOST_TEST_EQ(q.size(), 1u);
-//      BOOST_TEST(! q.closed());
-//  }
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if 0
+  {
+    // empty queue try_push rvalue succeeds
+      boost::concurrent::sync_priority_queue<int> q;
+      BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(1));
+      BOOST_TEST(! q.empty());
+      BOOST_TEST(! q.full());
+      BOOST_TEST_EQ(q.size(), 1u);
+      BOOST_TEST(! q.closed());
+  }
   {
     // empty queue nonblocking_push rvalue/non-copyable succeeds
       boost::concurrent::sync_priority_queue<non_copyable> q;
@@ -203,17 +200,16 @@ int main()
       BOOST_TEST_EQ(q.size(), 1u);
       BOOST_TEST(! q.closed());
   }
-#endif
+  {
-//  {
+    // empty queue nonblocking_push rvalue/non-copyable succeeds
-//    // empty queue nonblocking_push rvalue/non-copyable succeeds
+      boost::concurrent::sync_priority_queue<non_copyable> q;
-//      boost::concurrent::sync_priority_queue<non_copyable> q;
+      non_copyable nc(1);
-//      non_copyable nc(1);
+      BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(boost::move(nc)));
-//      BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(boost::move(nc)));
+      BOOST_TEST(! q.empty());
-//      BOOST_TEST(! q.empty());
+      BOOST_TEST(! q.full());
-//      BOOST_TEST(! q.full());
+      BOOST_TEST_EQ(q.size(), 1u);
-//      BOOST_TEST_EQ(q.size(), 1u);
+      BOOST_TEST(! q.closed());
-//      BOOST_TEST(! q.closed());
+  }
-//  }
 #endif
 
   {

test/sync/mutual_exclusion/sync_queue/single_thread_pass.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2013 Vicente J. Botet Escriba
+// Copyright (C) 2013,2015 Vicente J. Botet Escriba
 //
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -47,7 +47,7 @@ int main()
       BOOST_TEST(! q.closed());
   }
 
-#if 0
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   {
     // empty queue push rvalue/non_copyable succeeds
       boost::sync_queue<non_copyable> q;
@@ -108,11 +108,11 @@ int main()
       BOOST_TEST(! q.closed());
   }
 
-#if 0
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   {
     // empty queue try_push rvalue/non-copyable succeeds
       boost::sync_queue<non_copyable> q;
-      BOOST_TEST(boost::queue_op_status::success ==q.try_push(non_copyable()));
+      BOOST_TEST(boost::queue_op_status::success ==q.try_push(non_copyable(1)));
       BOOST_TEST(! q.empty());
       BOOST_TEST(! q.full());
       BOOST_TEST_EQ(q.size(), 1u);
@@ -150,7 +150,7 @@ int main()
       BOOST_TEST(! q.closed());
   }
 
-#if 0
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   {
     // empty queue nonblocking_push rvalue/non-copyable succeeds
       boost::sync_queue<non_copyable> q;

test/test_11053.cpp

@@ -0,0 +1,70 @@
+// 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.hpp>
+#include <boost/thread/tss.hpp>
+#include <boost/shared_ptr.hpp>
+#include <iostream>
+
+struct A
+{
+    void DoWork()
+    {
+        std::cout << "A: doing work\n";
+        if (!m_ptr.get())
+            m_ptr.reset(new WorkSpace());
+        // do not very much
+        for (size_t i = 0; i < 10; ++i)
+            m_ptr->a += 10;
+    }
+
+private:
+    struct WorkSpace
+    {
+        int a;
+        WorkSpace() : a(0) {}
+    };
+    boost::thread_specific_ptr<WorkSpace> m_ptr;
+};
+
+struct B
+{
+    void DoWork()
+    {
+        std::cout << "B: doing work\n";
+        if (!m_ptr.get())
+            m_ptr.reset(new A());
+        m_ptr->DoWork();
+    }
+private:
+    boost::thread_specific_ptr<A> m_ptr;
+};
+
+struct C
+{
+    void DoWork()
+    {
+        std::cout << "C: doing work\n";
+        if (!m_ptr.get())
+            m_ptr.reset(new B());
+        m_ptr->DoWork();
+    }
+private:
+    boost::thread_specific_ptr<B> m_ptr;
+};
+
+int main(int ac, char** av)
+{
+    std::cout << "test starting\n";
+    boost::shared_ptr<C> p_C(new C);
+    boost::thread cWorker(&C::DoWork, p_C);
+    cWorker.join();
+    std::cout << "test stopping\n";
+    return 0;
+}
+
+
+

test/test_scheduled_tp.cpp

@@ -35,6 +35,13 @@ void func(steady_clock::time_point pushed, steady_clock::duration dur)
 {
     BOOST_TEST(pushed + dur < steady_clock::now());
 }
+void func2(scheduled_tp* tp, steady_clock::duration d)
+{
+  boost::function<void()> fn = boost::bind(func,steady_clock::now(),d);
+  tp->submit_after(fn, d);
+}
+
+
 
 void test_timing(const int n)
 {
@@ -67,8 +74,9 @@ void test_deque_multi(const int n)
     for(int i = 0; i < n; i++)
     {
         steady_clock::duration d = milliseconds(i*100);
-        boost::function<void()> fn = boost::bind(func,steady_clock::now(),d);
+        //boost::function<void()> fn = boost::bind(func,steady_clock::now(),d);
-        tg.create_thread(boost::bind(boost::mem_fn(&scheduled_tp::submit_after), &se, fn, d));
+        //tg.create_thread(boost::bind(boost::mem_fn(&scheduled_tp::submit_after), &se, fn, d));
+        tg.create_thread(boost::bind(func2, &se, d));
     }
     tg.join_all();
     //dtor is called here so execution will block untill all the closures