Branch for 2nd try at V2 removal

[SVN r77497]
Thread: Protect uses of Boost.Chrono for compilers don't providing support for
2026-02-03 09:42:16 +00:00 · 2012-03-23 12:04:44 +00:00 · 2012-03-21 21:05:26 +00:00 · 2012-03-20 23:49:31 +00:00 · 2012-03-20 07:48:36 +00:00 · 2012-03-19 12:12:21 +00:00
276 changed files with 24017 additions and 2036 deletions
--- a/build/Jamfile.v2
+++ b/build/Jamfile.v2
@@ -43,7 +43,16 @@ project boost/thread
      <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
      -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
      <tag>@$(__name__).tag
-    : default-build <threading>multi
+      <toolset>gcc:<cxxflags>-Wno-long-long
+      <define>BOOST_SYSTEM_NO_DEPRECATED
+      <library>/boost/system//boost_system
+
+    # : default-build <threading>multi
+    : usage-requirements  # pass these requirement to dependents (i.e. users)
+      <link>static:<define>BOOST_THREAD_BUILD_LIB=1
+      <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
+      <define>BOOST_SYSTEM_NO_DEPRECATED
+      <library>/boost/system//boost_system
    ;

 local rule default_threadapi ( )
@@ -151,6 +160,16 @@ rule usage-requirements ( properties * )
            # in that case?
        }
    }
+
+    if <toolset>vacpp in $(properties)
+    {
+        result += <define>BOOST_THREAD_DONT_USE_CHRONO ;
+    } 
+    else 
+    {
+        result += <library>/boost/chrono//boost_chrono ;
+    }
+
    return $(result) ;
 }

@@ -174,13 +193,21 @@ rule requirements ( properties * )
            }
        }
    }
+    if <toolset>vacpp in $(properties)
+    {
+        result += <define>BOOST_THREAD_DONT_USE_CHRONO ;
+    } 
+    else 
+    {
+        result += <library>/boost/chrono//boost_chrono ;
+    }
+
    return $(result) ;
 }

 alias thread_sources
    : ## win32 sources ##
      win32/thread.cpp
-      win32/exceptions.cpp
      win32/tss_dll.cpp
      win32/tss_pe.cpp
    : ## requirements ##
@@ -190,7 +217,6 @@ alias thread_sources
 alias thread_sources
    : ## pthread sources ##
      pthread/thread.cpp
-      pthread/exceptions.cpp
      pthread/once.cpp
    : ## requirements ##
      <threadapi>pthread
@@ -199,7 +225,7 @@ alias thread_sources
 explicit thread_sources ;

 lib boost_thread
-    : thread_sources
+    : thread_sources future.cpp
    : <conditional>@requirements
    :
    : <link>shared:<define>BOOST_THREAD_USE_DLL=1
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -1,4 +1,5 @@
-# (C) Copyright 2008 Anthony Williams
+# (C) Copyright 2008-11 Anthony Williams
+# (C) Copyright 2011-12 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)
@@ -15,41 +16,17 @@ boostbook standalone
        # Use graphics not text for navigation:
        <xsl:param>navig.graphics=1
        # How far down we chunk nested sections, basically all of them:
-        <xsl:param>chunk.section.depth=3
+        <xsl:param>chunk.section.depth=2
        # Don't put the first section on the same page as the TOC:
        <xsl:param>chunk.first.sections=1
        # How far down sections get TOC's
-        <xsl:param>toc.section.depth=10
+        <xsl:param>toc.section.depth=4
        # Max depth in each TOC:
-        <xsl:param>toc.max.depth=3
+        <xsl:param>toc.max.depth=2
        # How far down we go with TOC's
        <xsl:param>generate.section.toc.level=10
        # Path for links to Boost:
        <xsl:param>boost.root=../../../..
-        # Path for libraries index:
-        <xsl:param>boost.libraries=../../../../libs/libraries.htm
-        # Use the main Boost stylesheet:
-        <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
-        
-        # PDF Options:
-        # TOC Generation: this is needed for FOP-0.9 and later:
-        #<xsl:param>fop1.extensions=1
-        # Or enable this if you're using XEP:
-        <xsl:param>xep.extensions=1
-        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
-        <xsl:param>fop.extensions=0
-        # No indent on body text:
-        <xsl:param>body.start.indent=0pt
-        # Margin size:
-        <xsl:param>page.margin.inner=0.5in
-        # Margin size:
-        <xsl:param>page.margin.outer=0.5in
-        # Yes, we want graphics for admonishments:
-        <xsl:param>admon.graphics=1
-        # Set this one for PDF generation *only*:
-        # default pnd graphics are awful in PDF form,
-        # better use SVG's instead:
-        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
-        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
    ;

+
--- a/doc/acknowledgements.qbk
+++ b/doc/acknowledgements.qbk
@@ -1,3 +1,10 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
 [section:acknowledgements Acknowledgments]

 The original implementation of __boost_thread__ was written by William Kempf, with contributions from numerous others. This new
--- a/doc/barrier.qbk
+++ b/doc/barrier.qbk
@@ -1,3 +1,10 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
 [section:barriers Barriers]

 A barrier is a simple concept. Also known as a ['rendezvous], it is a synchronization point between multiple threads. The barrier is
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -1,4 +1,105 @@
-[section:changes Changes since boost 1.34]
+[/
+  (C) Copyright 2007-11 Anthony Williams.
+  (C) Copyright 2011-12 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).
+]
+
+[section:changes History]
+
+[heading Version 2.0.0 - boost 1.50]
+
+New Features:
+
+* [@http://svn.boost.org/trac/boost/ticket/2741 #2741] Proposal to manage portable and non portable thread attributes. 
+* [@http://svn.boost.org/trac/boost/ticket/6195 #6195] c++11 compliance: Provide the standard time related interface using Boost.Chrono. 
+* [@http://svn.boost.org/trac/boost/ticket/6224 #6224] c++11 compliance: Add the use of standard noexcept on compilers supporting them. 
+* [@http://svn.boost.org/trac/boost/ticket/6226 #6226] c++11 compliance: Add explicit bool conversion from locks. 
+* [@http://svn.boost.org/trac/boost/ticket/6230 #6230] c++11 compliance: Follows the exception reporting mechanism as defined in the c++11. 
+* [@http://svn.boost.org/trac/boost/ticket/6272 #6272] c++11 compliance: Add thread::id hash specialization.
+* [@http://svn.boost.org/trac/boost/ticket/6273 #6273] c++11 compliance: Add cv_status enum class and use it on the conditions wait functions. 
+* [@http://svn.boost.org/trac/boost/ticket/6194 #6194] Adapt to Boost.Move. 
+ 	
+Fixed Bugs:
+
+* [@http://svn.boost.org/trac/boost/ticket/2575 #2575] Bug- Boost 1.36.0 on Itanium platform.
+* [@http://svn.boost.org/trac/boost/ticket/4921 #4921] BOOST_THREAD_USE_DLL and BOOST_THREAD_USE_LIB are crucial and need to be documented.
+* [@http://svn.boost.org/trac/boost/ticket/5013 #5013] documentation: boost::thread: pthreas_exit causes terminate().
+
+* [@http://svn.boost.org/trac/boost/ticket/5351 #5351] interrupt a future get boost::unknown_exception.
+* [@http://svn.boost.org/trac/boost/ticket/5516 #5516] Upgrade lock is not acquired when previous upgrade lock releases if another read lock is present. 
+* [@http://svn.boost.org/trac/boost/ticket/5990 #5990] shared_future<T>::get() has wrong return type. 
+* [@http://svn.boost.org/trac/boost/ticket/6174 #6174] packaged_task doesn't correctly handle moving results.
+ 	
+[/
+
+Deprecated features since boost 1.50 available only until boost 1.55:
+
+These deprecated features will be provided by default up to boost 1.52. If you don't want to include the deprecated features you could define BOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0. Since 1.53 these features will not be included any more by default. Since this version, if you want to include the deprecated features yet you could define BOOST_THREAD_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0. These deprecated features will be only available until boost 1.55, that is you have 1 year and a half to move to the new features.
+
+* Time related functions don't using the Boost.Chrono library, use the chrono overloads instead.
+
+Breaking changes:
+
+There are some new features which share the same interface but with different behavior. These breaking features are not provided by default when BOOST_THREAD_VERSION is 2, but the user can however choose the version 1 behavior by defining the corresponding macro. As for the deprecated features, these broken features will be only available until boost 1.55.
+
+*  #6266 	c++11 compliance: thread destructor should call terminate if joinable
+*  #6269 	c++11 compliance: thread move assignment should call terminate if joinable
+]
+
+[heading boost 1.49]
+
+Fixed Bugs:
+
+* [@http://svn.boost.org/trac/boost/ticket/2309 #2309] Lack of g++ symbol visibility support in Boost.Thread. 
+* [@http://svn.boost.org/trac/boost/ticket/2639 #2639] documentation should be extended(defer_lock, try_to_lock, ...).
+
+* [@http://svn.boost.org/trac/boost/ticket/3639 #3639] Boost.Thread doesn't build with Sun-5.9 on Linux.
+* [@http://svn.boost.org/trac/boost/ticket/3762 #3762] Thread can't be compiled with winscw (Codewarrior by Nokia).
+* [@http://svn.boost.org/trac/boost/ticket/3885 #3885] document about mix usage of boost.thread and native thread api.
+* [@http://svn.boost.org/trac/boost/ticket/3975 #3975] Incorrect precondition for promise::set_wait_callback().
+
+* [@http://svn.boost.org/trac/boost/ticket/4048 #4048] thread::id formatting involves locale
+* [@http://svn.boost.org/trac/boost/ticket/4315 #4315] gcc 4.4 Warning: inline ... declared as dllimport: attribute ignored. 
+* [@http://svn.boost.org/trac/boost/ticket/4480 #4480] OpenVMS patches for compiler issues workarounds.
+* [@http://svn.boost.org/trac/boost/ticket/4819 #4819] boost.thread's documentation misprints.
+
+* [@http://svn.boost.org/trac/boost/ticket/5423 #5423] thread issues with C++0x.
+* [@http://svn.boost.org/trac/boost/ticket/5617 #5617] boost::thread::id copy ctor.
+* [@http://svn.boost.org/trac/boost/ticket/5739 #5739] set-but-not-used warnings with gcc-4.6.
+* [@http://svn.boost.org/trac/boost/ticket/5826 #5826] threads.cpp: resource leak on threads creation failure.
+* [@http://svn.boost.org/trac/boost/ticket/5839 #5839] thread.cpp: ThreadProxy leaks on exceptions.
+* [@http://svn.boost.org/trac/boost/ticket/5859 #5859] win32 shared_mutex constructor leaks on exceptions. 
+
+* [@http://svn.boost.org/trac/boost/ticket/6100 #6100] Compute hardware_concurrency() using get_nprocs() on GLIBC systems.
+* [@http://svn.boost.org/trac/boost/ticket/6168 #6168] recursive_mutex is using wrong config symbol (possible typo).
+* [@http://svn.boost.org/trac/boost/ticket/6175 #6175] Compile error with SunStudio.
+* [@http://svn.boost.org/trac/boost/ticket/6200 #6200] patch to have condition_variable and mutex error better handle EINTR. 
+* [@http://svn.boost.org/trac/boost/ticket/6207 #6207] shared_lock swap compiler error on clang 3.0 c++11. 
+* [@http://svn.boost.org/trac/boost/ticket/6208 #6208] try_lock_wrapper swap compiler error on clang 3.0 c++11. 
+
+[heading Changes since boost 1.40]
+
+The 1.41.0 release of Boost adds futures to the thread library. There are also a few minor changes.
+
+[heading Changes since boost 1.35]
+
+The 1.36.0 release of Boost includes a few new features in the thread library:
+
+* New generic __lock_multiple_ref__ and __try_lock_multiple_ref__ functions for locking multiple mutexes at once.
+
+* Rvalue reference support for move semantics where the compilers supports it.
+
+* A few bugs fixed and missing functions added (including the serious win32 condition variable bug).
+
+* `scoped_try_lock` types are now backwards-compatible with Boost 1.34.0 and previous releases.
+
+* Support for passing function arguments to the thread function by supplying additional arguments to the __thread__ constructor.
+
+* Backwards-compatibility overloads added for `timed_lock` and `timed_wait` functions to allow use of `xtime` for timeouts.
+
+[heading Changes since boost 1.34]

 Almost every line of code in __boost_thread__ has been changed since the 1.34 release of boost. However, most of the interface
 changes have been extensions, so the new code is largely backwards-compatible with the old code. The new features and breaking
@@ -54,4 +155,22 @@ been moved to __thread_id__.

 * __mutex__ is now never recursive. For Boost releases prior to 1.35 __mutex__ was recursive on Windows and not on POSIX platforms.

+* When using a __recursive_mutex__ with a call to [cond_any_wait_link `boost::condition_variable_any::wait()`], the mutex is only
+  unlocked one level, and not completely. This prior behaviour was not guaranteed and did not feature in the tests.
+
 [endsect]
+
+[section:future Future]
+
+The following features will be included in next releases. By order of priority:
+
+* [@http://svn.boost.org/trac/boost/ticket/4710 #4710] Missing async(). 
+* Lock guards
+  * [@http://svn.boost.org/trac/boost/ticket/1850 #1850]	request for unlock_guard (and/or unique_unlock) to compliment lock_guard/unique_lock
+  * [@http://svn.boost.org/trac/boost/ticket/3567 #3567] 	Request for shared_lock_guard
+* #2880 	Request for Thread scheduler support for boost ..
+* #3696 	Boost Thread library lacks any way to set priority of threads
+* #5956 	Add optional stack_size argument to thread::start_thread()
+
+[endsect]
+
--- a/doc/compliance.qbk
+++ b/doc/compliance.qbk
@@ -0,0 +1,101 @@
+[/
+  (C) Copyright 2011-12 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).
+]
+
+[section:compliance Compliance with standard]
+
+[section:cpp11 C++11 standard Thread library]
+
+
+[table Compliance C++11 standard
+    [[Section]        [Description]  [Status] [Comments] [Ticket]]
+    [[30]        [Thread support library]  [Partial] [-] [-]]
+    [[30.1]        [General]  [-] [-] [-]]
+    [[30.2]        [Requirements]  [-] [-] [-]]
+    [[30.2.1]        [Template parameter names]  [-] [-] [-]]
+    [[30.2.2]        [Exceptions]  [Yes] [-] [#6230]]
+    [[30.2.3]        [Native handles]  [Yes] [-] [-]]
+    [[30.2.4]        [Timing specifications]  [Yes] [-] [#6195]]
+    [[30.2.5]        [Requirements for Lockable types]  [Partial] [-] [-]]
+    [[30.2.5.1]        [In general]  [-] [-] [-]]
+    [[30.2.5.2]        [BasicLockable requirements]  [No] [-] [#6231]]
+    [[30.2.5.3]        [Lockable requirements]  [yes] [-] [-]]
+    [[30.2.5.4]        [TimedLockable requirements]  [Yes] [-] [#6195]]
+    [[30.2.6]        [decay_copy]  [-] [-] [-]]
+    [[30.3]        [Threads]  [Partial] [-] [-]]
+    [[30.3.1]        [Class thread]  [Partial] [move,terminate] [-]]
+    [[30.3.1.1]        [Class thread::id]  [Yes] [-] [#6224,#6272]]
+    [[30.3.1.2]        [thread constructors]  [Partial] [move] [#6224,#6194, #6270]]
+    [[30.3.1.3]        [thread destructor]  [Partial] [terminate] [#6266]]
+    [[30.3.1.4]        [thread assignment]  [Partial] [move, terminate] [#6269]]
+    [[30.3.1.5]        [thread members]  [Yes] [-] [#6224,#6195]]
+    [[30.3.1.6]        [thread static members]  [Yes] [-] [#6224]]
+    [[30.3.1.7]        [thread specialized algorithms]  [Yes] [-] [-]]
+
+    [[30.3.2]        [Namespace this_thread]  [Yes] [-] [#6195]]
+    [[30.4]        [Mutual exclusion]  [Partial] [move] [-]]
+    [[30.4.1]        [Mutex requirements]  [Yes] [-] [-]]
+    [[30.4.1.1]        [In general]  [Yes] [-] [-]]
+    [[30.4.1.2]        [Mutex types]  [Yes] [-] [#6224,#6225]]
+    [[30.4.1.2.1]        [Class mutex]  [Yes] [-] [#6224,#6225]]
+    [[30.4.1.2.2]        [Class recursive_mutex]  [Yes] [-] [#6224,#6225]]
+    [[30.4.1.3]        [Timed mutex types]  [Yes] [-] [#6224,#6195,#6225]]
+    [[30.4.1.3.1]        [Class timed_mutex]  [Yes] [-] [#6224,#6195,#6225]]
+    [[30.4.1.3.1]        [Class recursive_timed_mutex]  [Yes] [-] [#6224,#6195,#6225]]
+    [[30.4.2]        [Locks]  [Partial] [move] [#6224,#6195,#6225,#6227]]
+    [[30.4.2.1]        [Class template lock_guard]  [Yes] [-] [#6225]]
+    [[30.4.2.2]        [Class template unique_lock]  [Yes] [move] [#6224,#6195,#6225,#6227]]
+    [[30.4.2.2.1]        [unique_lock constructors, destructor, and assignment] [Partial]  [move]  [#6224,#6195,#6225,#6227]]
+    [[30.4.2.2.2]        [unique_lock locking]  [Yes] [-] [#6195]]
+    [[30.4.2.2.3]        [unique_lock modifiers]  [Yes] [-] [-]]
+    [[30.4.2.2.4]        [unique_lock observers]  [Yes] [] [#6227]]
+    [[30.4.3]        [Generic locking algorithms]  [Partial] [variadic] [#6227]]
+    [[30.4.4]        [Call once]  [Partial] [move,variadic,] [#6194,#7]]
+    [[30.4.4.1]        [Struct once_flag] [Partial] [interface] [#xx]]
+    [[30.4.4.2]        [Function call_once] [Partial] [move,variadic,interface] [#xx]]
+    [[30.5]        [Condition variables]  [Partial] [notify_all_at_thread_exit] [#6195,#6273,#9]]
+    [[30.5 6-10]        [Function notify_all_at_thread_exit]  [No] [-] [#9]]
+    [[30.5.1]        [Class condition_variable]  [Yes] [-] [#6195,#6273]]
+    [[30.5.2]        [Class condition_variable_any]  [Yes] [-] [#6195,#6273]]
+    [[30.6]        [Futures]  [Partial] [-] [-]]
+    [[30.6.1]        [Overview]  [Partial] [-] [-]]
+    [[30.6.2]        [Error handling]  [No] [-] [-]]
+    [[30.6.3]        [Class future_error]  [No] [-] [-]]
+    [[30.6.4]        [Shared state]  [No] [-] [-]]
+    [[30.6.5]        [Class template promise]  [Partial] [allocator,move] [#6228,#6194,#6225]]
+    [[30.6.6]        [Class template future]  [No] [unique_future is the closest to future] [##6229,#6228]]
+    [[30.6.7]        [Class template shared_future]  [Partial] [allocator,move] [#6228,#6194,#6225]]
+    [[30.6.8]        [Function template async]  [No] [async] [#4710]]
+    [[30.6.8]        [Class template packaged_task]  [Partial] [move] [#6194]]
+]
+
+[/
+[table Extension
+    [[Section]     [Description]   [Comments]]
+    [[30.3.1.5.x]        [interrupt]   [-]]
+    [[30.3.2.x]        [Interruption]  [-]]
+    [[30.3.2.y]        [at_thread_exit]  [-]]
+    [[30.4.3.x]        [Generic locking algorithms begin/end]  [-]]
+    [[30.x]        [Barriers]  [-]]
+    [[30.y]        [Thread Local Storage]  [-]]
+    [[30.z]        [Class thread_group]  [-]]
+]
+]
+[endsect]
+
+[/
+[section:shared Shared Mutex library extension]
+
+[table Clock Requirements
+    [[Section]        [Description]  [Status] [Comments]]
+    [[XXXX]        [DDDD]  [SSSS] [CCCC]]
+    [[XXXX]        [DDDD]  [SSSS] [CCCC]]
+]
+
+[endsect]
+]
+
+[endsect]
--- a/doc/condition_variables.qbk
+++ b/doc/condition_variables.qbk
@@ -1,7 +1,26 @@
+[/
+  (C) Copyright 2007-11 Anthony Williams.
+  (C) Copyright 2011-12 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).
+]
+
 [section:condvar_ref Condition Variables]

 [heading Synopsis]

+  namespace boost 
+  {
+    enum class cv_status;
+    {
+      no_timeout,
+      timeout
+    };
+    class condition_variable;
+    class condition_variable_any;
+  }
+
 The classes `condition_variable` and `condition_variable_any` provide a
 mechanism for one thread to wait for notification from another thread that a
 particular condition has become true. The general usage pattern is that one
@@ -67,6 +86,8 @@ optimizations in some cases, based on the knowledge of the mutex type;

 [section:condition_variable Class `condition_variable`]

+    #include <boost/thread/condition_variable.hpp>
+
    namespace boost
    {
        class condition_variable
@@ -75,28 +96,57 @@ optimizations in some cases, based on the knowledge of the mutex type;
            condition_variable();
            ~condition_variable();

+            void notify_one() noexcept;
+            void notify_all() noexcept;
+
            void wait(boost::unique_lock<boost::mutex>& lock);

            template<typename predicate_type>
            void wait(boost::unique_lock<boost::mutex>& lock,predicate_type predicate);

-            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time);
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time); // DEPRECATED V2

            template<typename duration_type>
-            bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time);
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time); // DEPRECATED V2

            template<typename predicate_type>
-            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time,predicate_type predicate);
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time,predicate_type predicate); // DEPRECATED V2

            template<typename duration_type,typename predicate_type>
-            bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time,predicate_type predicate);
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time,predicate_type predicate); // DEPRECATED V2
+
+            template <class Clock, class Duration>
+            typename cv_status::type
+            wait_until(
+                unique_lock<mutex>& lock,
+                const chrono::time_point<Clock, Duration>& t);
+
+            template <class Clock, class Duration, class Predicate>
+            bool
+            wait_until(
+                unique_lock<mutex>& lock,
+                const chrono::time_point<Clock, Duration>& t,
+                Predicate pred);
+
+            template <class Rep, class Period>
+            typename cv_status::type
+            wait_for(
+                unique_lock<mutex>& lock,
+                const chrono::duration<Rep, Period>& d);
+
+            template <class Rep, class Period, class Predicate>
+            bool
+            wait_for(
+                unique_lock<mutex>& lock,
+                const chrono::duration<Rep, Period>& d,
+                Predicate pred);

        // backwards compatibility

-            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time);
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time); // DEPRECATED V2

            template<typename predicate_type>
-            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time,predicate_type predicate);
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time,predicate_type predicate); // DEPRECATED V2
        };
    }

@@ -196,7 +246,7 @@ while(!pred())

 [endsect]

-[section:timed_wait `bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time)`]
+[section:timed_wait `bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time)` DEPRECATED V2]

 [variablelist

@@ -227,7 +277,7 @@ __interrupt__ on the __thread__ object associated with the current thread of exe

 [endsect]

-[section:timed_wait_rel `template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time)`]
+[section:timed_wait_rel `template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time)` DEPRECATED V2]

 [variablelist

@@ -260,7 +310,7 @@ __interrupt__ on the __thread__ object associated with the current thread of exe

 [endsect]

-[section:timed_wait_predicate `template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock, boost::system_time const& abs_time, predicate_type pred)`]
+[section:timed_wait_predicate `template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock, boost::system_time const& abs_time, predicate_type pred)` DEPRECATED V2]

 [variablelist

@@ -280,10 +330,120 @@ return true;
 [endsect]


+[section:wait_until `template <class Clock, class Duration> cv_status wait_until(boost::unique_lock<boost::mutex>& lock, const chrono::time_point<Clock, Duration>& abs_time)`]
+
+[variablelist
+
+[[Precondition:] [`lock` is locked by the current thread, and either no other
+thread is currently waiting on `*this`, or the execution of the `mutex()` member
+function on the `lock` objects supplied in the calls to `wait` or `wait_for` or `wait_until`
+in all the threads currently waiting on `*this` would return the same value as
+`lock->mutex()` for this call to `wait`.]]
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, when the time as reported by `Clock::now()`
+would be equal to or later than the specified `abs_time`, or spuriously. When
+the thread is unblocked (for whatever reason), the lock is reacquired by
+invoking `lock.lock()` before the call to `wait` returns. The lock is also
+reacquired by invoking `lock.lock()` if the function exits with an exception.]]
+
+[[Returns:] [`cv_status::no_timeout` if the call is returning because the time specified by
+`abs_time` was reached, `cv_status::timeout` otherwise.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[endsect]
+
+[section:wait_for `template <class Rep, class Period> cv_status wait_for(boost::unique_lock<boost::mutex>& lock, const chrono::duration<Rep, Period>& rel_time)`]
+
+
+[variablelist
+
+[[Precondition:] [`lock` is locked by the current thread, and either no other
+thread is currently waiting on `*this`, or the execution of the `mutex()` member
+function on the `lock` objects supplied in the calls to `wait` or `wait_until` or `wait_for`
+in all the threads currently waiting on `*this` would return the same value as
+`lock->mutex()` for this call to `wait`.]]
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, after the period of time indicated by the `rel_time`
+argument has elapsed, or spuriously. When the thread is unblocked (for whatever
+reason), the lock is reacquired by invoking `lock.lock()` before the call to
+`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
+function exits with an exception.]]
+
+[[Returns:] [`cv_status::no_timeout ` if the call is returning because the time period specified
+by `rel_time` has elapsed, `cv_status::timeout ` otherwise.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[note The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases.]
+
+[endsect]
+
+[section:wait_until_predicate `template <class Clock, class Duration, class Predicate> bool wait_until(boost::unique_lock<boost::mutex>& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred)`]
+
+
+[variablelist
+
+[[Effects:] [As-if ``
+while(!pred())
+{
+    if(!wait_until(lock,abs_time))
+    {
+        return pred();
+    }
+}
+return true;
+``]]
+
+]
+
+[endsect]
+
+[section:wait_for_predicate `template <class Rep, class Period, class Predicate> bool wait_for(boost::unique_lock<boost::mutex>& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred)`]
+
+
+[variablelist
+
+[[Effects:] [As-if ``
+while(!pred())
+{
+    if(!wait_for(lock,rel_time))
+    {
+        return pred();
+    }
+}
+return true;
+``]]
+
+]
+
+[endsect]
+
+
+
+
 [endsect]

 [section:condition_variable_any Class `condition_variable_any`]

+    #include <boost/thread/condition_variable.hpp>
+
    namespace boost
    {
        class condition_variable_any
@@ -292,6 +452,9 @@ return true;
            condition_variable_any();
            ~condition_variable_any();

+            void notify_one();
+            void notify_all();
+
            template<typename lock_type>
            void wait(lock_type& lock);

@@ -299,24 +462,47 @@ return true;
            void wait(lock_type& lock,predicate_type predicate);

            template<typename lock_type>
-            bool timed_wait(lock_type& lock,boost::system_time const& abs_time);
+            bool timed_wait(lock_type& lock,boost::system_time const& abs_time) // DEPRECATED V2;

            template<typename lock_type,typename duration_type>
-            bool timed_wait(lock_type& lock,duration_type const& rel_time);
+            bool timed_wait(lock_type& lock,duration_type const& rel_time) // DEPRECATED V2;

            template<typename lock_type,typename predicate_type>
-            bool timed_wait(lock_type& lock,boost::system_time const& abs_time,predicate_type predicate);
+            bool timed_wait(lock_type& lock,boost::system_time const& abs_time,predicate_type predicate) // DEPRECATED V2;

            template<typename lock_type,typename duration_type,typename predicate_type>
-            bool timed_wait(lock_type& lock,duration_type const& rel_time,predicate_type predicate);
+            bool timed_wait(lock_type& lock,duration_type const& rel_time,predicate_type predicate) // DEPRECATED V2;
+
+            template <class lock_type, class Clock, class Duration>
+            cv_status wait_until(
+                lock_type& lock,
+                const chrono::time_point<Clock, Duration>& t);
+
+            template <class lock_type, class Clock, class Duration, class Predicate>
+            bool wait_until(
+                lock_type& lock,
+                const chrono::time_point<Clock, Duration>& t,
+                Predicate pred);
+
+
+            template <class lock_type, class Rep, class Period>
+            cv_status wait_for(
+                lock_type& lock,
+                const chrono::duration<Rep, Period>& d);
+
+            template <class lock_type, class Rep, class Period, class Predicate>
+            bool wait_for(
+                lock_type& lock,
+                const chrono::duration<Rep, Period>& d,
+                Predicate pred);

        // backwards compatibility

            template<typename lock_type>
-            bool timed_wait(lock_type>& lock,boost::xtime const& abs_time);
+            bool timed_wait(lock_type>& lock,boost::xtime const& abs_time) // DEPRECATED V2;

            template<typename lock_type,typename predicate_type>
-            bool timed_wait(lock_type& lock,boost::xtime const& abs_time,predicate_type predicate);
+            bool timed_wait(lock_type& lock,boost::xtime const& abs_time,predicate_type predicate) // DEPRECATED V2;
        };
    }

@@ -410,7 +596,7 @@ while(!pred())

 [endsect]

-[section:timed_wait `template<typename lock_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time)`]
+[section:timed_wait `template<typename lock_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time)` DEPRECATED V2]

 [variablelist

@@ -435,7 +621,7 @@ __interrupt__ on the __thread__ object associated with the current thread of exe

 [endsect]

-[section:timed_wait_rel `template<typename lock_type,typename duration_type> bool timed_wait(lock_type& lock,duration_type const& rel_time)`]
+[section:timed_wait_rel `template<typename lock_type,typename duration_type> bool timed_wait(lock_type& lock,duration_type const& rel_time)` DEPRECATED V2]

 [variablelist

@@ -462,7 +648,7 @@ __interrupt__ on the __thread__ object associated with the current thread of exe

 [endsect]

-[section:timed_wait_predicate `template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock, boost::system_time const& abs_time, predicate_type pred)`]
+[section:timed_wait_predicate `template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock, boost::system_time const& abs_time, predicate_type pred)` DEPRECATED V2]

 [variablelist

@@ -481,10 +667,102 @@ return true;

 [endsect]

+[section:wait_until `template <class lock_type, class Clock, class Duration> cv_status wait_until(lock_type& lock, const chrono::time_point<Clock, Duration>& abs_time)`]
+
+[variablelist
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, when the time as reported by `Clock::now()`
+would be equal to or later than the specified `abs_time`, or spuriously. When
+the thread is unblocked (for whatever reason), the lock is reacquired by
+invoking `lock.lock()` before the call to `wait` returns. The lock is also
+reacquired by invoking `lock.lock()` if the function exits with an exception.]]
+
+[[Returns:] [`cv_status::timeout` if the call is returning because the time specified by
+`abs_time` was reached, `cv_status::no_timeout` otherwise.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[endsect]
+
+[section:wait_for `template <class lock_type, class Rep, class Period> cv_status wait_for(lock_type& lock, const chrono::duration<Rep, Period>& rel_time)`]
+
+[variablelist
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, after the period of time indicated by the `rel_time`
+argument has elapsed, or spuriously. When the thread is unblocked (for whatever
+reason), the lock is reacquired by invoking `lock.lock()` before the call to
+`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
+function exits with an exception.]]
+
+[[Returns:] [`cv_status::timeout` if the call is returning because the time specified by
+`abs_time` was reached, `cv_status::no_timeout` otherwise.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[note The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases.]
+
+[endsect]
+
+[section:wait_until_predicate `template <class lock_type, class Clock, class Duration, class Predicate> bool wait_until(lock_type& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred)`]
+
+[variablelist
+
+[[Effects:] [As-if ``
+while(!pred())
+{
+    if(!__cvany_wait_until(lock,abs_time))
+    {
+        return pred();
+    }
+}
+return true;
+``]]
+
+]
+
+[endsect]
+
+[section:wait_for_predicate `template <class lock_type, class Rep, class Period, class Predicate> bool wait_until(lock_type& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred)`]
+
+[variablelist
+
+[[Effects:] [As-if ``
+while(!pred())
+{
+    if(!__cvany_wait_for(lock,rel_time))
+    {
+        return pred();
+    }
+}
+return true;
+``]]
+
+]
+
+[endsect]
+
 [endsect]

 [section:condition Typedef `condition`]

+    #include <boost/thread/condition.hpp>
+
    typedef condition_variable_any condition;

 The typedef `condition` is provided for backwards compatibility with previous boost releases.
--- a/doc/future_ref.qbk
+++ b/doc/future_ref.qbk
@@ -0,0 +1,968 @@
+[/
+  (C) Copyright 2008-11 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:reference Futures Reference]
+
+[section:future_state `state` enum]
+
+    namespace future_state
+    {
+        enum state {uninitialized, waiting, ready};
+    }
+
+[endsect]
+
+[section:unique_future `unique_future` class template]
+
+    template <typename R>
+    class unique_future
+    {
+        unique_future(unique_future & rhs);// = delete;
+        unique_future& operator=(unique_future& rhs);// = delete;
+
+    public:
+        typedef future_state::state state;
+
+        unique_future();
+        ~unique_future();
+
+        // move support
+        unique_future(unique_future && other);
+        unique_future& operator=(unique_future && other);
+
+        void swap(unique_future& other);
+
+        // retrieving the value
+        R&& get();        
+
+        // functions to check state
+        state get_state() const;
+        bool is_ready() const;        
+        bool has_exception() const;        
+        bool has_value() const;        
+
+        // waiting for the result to be ready
+        void wait() const;        
+        template<typename Duration>
+        bool timed_wait(Duration const& rel_time) const;
+        bool timed_wait_until(boost::system_time const& abs_time) const;
+    };
+
+[section:default_constructor Default Constructor]
+
+    unique_future();
+
+[variablelist
+
+[[Effects:] [Constructs an uninitialized future.]]
+
+[[Postconditions:] [[unique_future_is_ready_link `this->is_ready`] returns `false`. [unique_future_get_state_link
+`this->get_state()`] returns __uninitialized__.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:destructor Destructor]
+
+    ~unique_future();
+
+[variablelist
+
+[[Effects:] [Destroys `*this`.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:move_constructor Move Constructor]
+
+    unique_future(unique_future && other);
+
+[variablelist
+
+[[Effects:] [Constructs a new future, and transfers ownership of the asynchronous result associated with `other` to `*this`.]]
+
+[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
+call. `other->get_state()` returns __uninitialized__. If `other` was associated with an asynchronous result, that result is now
+associated with `*this`. `other` is not associated with any asynchronous result.]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:move_assignment Move Assignment Operator]
+
+    unique_future& operator=(unique_future && other);
+
+[variablelist
+
+[[Effects:] [Transfers ownership of the asynchronous result associated with `other` to `*this`.]]
+
+[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
+call. `other->get_state()` returns __uninitialized__. If `other` was associated with an asynchronous result, that result is now
+associated with `*this`. `other` is not associated with any asynchronous result. If `*this` was associated with an asynchronous
+result prior to the call, that result no longer has an associated __unique_future__ instance.]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:swap Member function `swap()`]
+
+    void swap(unique_future & other);
+
+[variablelist
+
+[[Effects:] [Swaps ownership of the asynchronous results associated with `other` and `*this`.]]
+
+[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
+call. `other->get_state()` returns the value of `this->get_state()` prior to the call. If `other` was associated with an
+asynchronous result, that result is now associated with `*this`, otherwise `*this` has no associated result. If `*this` was
+associated with an asynchronous result, that result is now associated with `other`, otherwise `other` has no associated result.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[section:get Member function `get()`]
+
+    R&& get();
+    R& unique_future<R&>::get();
+    void unique_future<void>::get();
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready as-if by a call to
+__unique_future_wait__, and retrieves the result (whether that is a value or an exception).]]
+
+[[Returns:] [If the result type `R` is a reference, returns the stored reference. If `R` is `void`, there is no return
+value. Otherwise, returns an rvalue-reference to the value stored in the asynchronous result.]]
+
+[[Postconditions:] [[unique_future_is_ready_link `this->is_ready()`] returns `true`. [unique_future_get_state_link
+`this->get_state()`] returns __ready__.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception stored in the
+asynchronous result in place of a value.]]
+
+[[Notes:] [`get()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:wait Member function `wait()`]
+
+    void wait();
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready. If the result is not ready on
+entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [[unique_future_is_ready_link `this->is_ready()`] returns `true`. [unique_future_get_state_link
+`this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`wait()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:timed_wait_duration Member function `timed_wait()`]
+
+    template<typename Duration>
+    bool timed_wait(Duration const& wait_duration);
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time specified by
+`wait_duration` has elapsed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is
+invoked prior to waiting.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
+elapsed, `false` otherwise.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [If this call returned `true`, then [unique_future_is_ready_link `this->is_ready()`] returns `true` and
+[unique_future_get_state_link `this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`timed_wait()` is an ['interruption point]. `Duration` must be a type that meets the Boost.DateTime time duration requirements.]]
+
+]
+
+[endsect]
+
+[section:timed_wait_absolute Member function `timed_wait()`]
+
+    bool timed_wait(boost::system_time const& wait_timeout);
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time point specified by
+`wait_timeout` has passed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is invoked
+prior to waiting.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
+passed, `false` otherwise.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [If this call returned `true`, then [unique_future_is_ready_link `this->is_ready()`] returns `true` and
+[unique_future_get_state_link `this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`timed_wait()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+
+[section:is_ready Member function `is_ready()`]
+
+    bool is_ready();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready for retrieval, `false`
+otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:has_value Member function `has_value()`]
+
+    bool has_value();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with a value rather than an exception.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
+stored value, `false` otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:has_exception Member function `has_exception()`]
+
+    bool has_exception();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with an exception rather than a value.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
+stored exception, `false` otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get_state Member function `get_state()`]
+
+    future_state::state get_state();
+
+[variablelist
+
+[[Effects:] [Determine the state of the asynchronous result associated with `*this`, if any.]]
+
+[[Returns:] [__uninitialized__ if `*this` is not associated with an asynchronous result. __ready__ if the asynchronous result
+associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[section:shared_future `shared_future` class template]
+
+    template <typename R>
+    class shared_future
+    {
+    public:
+        typedef future_state::state state;
+
+        shared_future();
+        ~shared_future();
+
+        // copy support
+        shared_future(shared_future const& other);
+        shared_future& operator=(shared_future const& other);
+
+        // move support
+        shared_future(shared_future && other);
+        shared_future(unique_future<R> && other);
+        shared_future& operator=(shared_future && other);
+        shared_future& operator=(unique_future<R> && other);
+
+        void swap(shared_future& other);
+
+        // retrieving the value
+        R get();
+        
+        // functions to check state, and wait for ready
+        state get_state() const;
+        bool is_ready() const;
+        bool has_exception() const;
+        bool has_value() const;
+
+        // waiting for the result to be ready
+        void wait() const;        
+        template<typename Duration>
+        bool timed_wait(Duration const& rel_time) const;
+        bool timed_wait_until(boost::system_time const& abs_time) const;        
+    };
+
+[section:default_constructor Default Constructor]
+
+    shared_future();
+
+[variablelist
+
+[[Effects:] [Constructs an uninitialized future.]]
+
+[[Postconditions:] [[shared_future_is_ready_link `this->is_ready`] returns `false`. [shared_future_get_state_link
+`this->get_state()`] returns __uninitialized__.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get Member function `get()`]
+
+    const R& get();
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready as-if by a call to
+__shared_future_wait__, and returns a `const` reference to the result.]]
+
+[[Returns:] [If the result type `R` is a reference, returns the stored reference. If `R` is `void`, there is no return
+value. Otherwise, returns a `const` reference to the value stored in the asynchronous result.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the
+result associated with `*this` is not ready at the point of the call, and the current thread is interrupted.]]
+
+[[Notes:] [`get()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:wait Member function `wait()`]
+
+    void wait();
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready. If the result is not ready on
+entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [[shared_future_is_ready_link `this->is_ready()`] returns `true`. [shared_future_get_state_link
+`this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`wait()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:timed_wait_duration Member function `timed_wait()`]
+
+    template<typename Duration>
+    bool timed_wait(Duration const& wait_duration);
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time specified by
+`wait_duration` has elapsed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is
+invoked prior to waiting.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
+elapsed, `false` otherwise.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [If this call returned `true`, then [shared_future_is_ready_link `this->is_ready()`] returns `true` and
+[shared_future_get_state_link `this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`timed_wait()` is an ['interruption point]. `Duration` must be a type that meets the Boost.DateTime time duration requirements.]]
+
+]
+
+[endsect]
+
+[section:timed_wait_absolute Member function `timed_wait()`]
+
+    bool timed_wait(boost::system_time const& wait_timeout);
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time point specified by
+`wait_timeout` has passed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is invoked
+prior to waiting.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
+passed, `false` otherwise.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [If this call returned `true`, then [shared_future_is_ready_link `this->is_ready()`] returns `true` and
+[shared_future_get_state_link `this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`timed_wait()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:is_ready Member function `is_ready()`]
+
+    bool is_ready();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready for retrieval, `false`
+otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:has_value Member function `has_value()`]
+
+    bool has_value();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with a value rather than an exception.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
+stored value, `false` otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:has_exception Member function `has_exception()`]
+
+    bool has_exception();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with an exception rather than a value.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
+stored exception, `false` otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get_state Member function `get_state()`]
+
+    future_state::state get_state();
+
+[variablelist
+
+[[Effects:] [Determine the state of the asynchronous result associated with `*this`, if any.]]
+
+[[Returns:] [__uninitialized__ if `*this` is not associated with an asynchronous result. __ready__ if the asynchronous result
+associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[section:promise `promise` class template]
+
+    template <typename R>
+    class promise
+    {
+        promise(promise & rhs);// = delete;
+        promise & operator=(promise & rhs);// = delete;
+    public:
+        // template <class Allocator> explicit promise(Allocator a);
+
+        promise();
+        ~promise();
+
+        // Move support
+        promise(promise && rhs);
+        promise & operator=(promise&& rhs);
+        
+        void swap(promise& other);
+        // Result retrieval
+        unique_future<R> get_future();
+
+        // Set the value
+        void set_value(R& r);
+        void set_value(R&& r);
+        void set_exception(boost::exception_ptr e);
+
+        template<typename F>
+        void set_wait_callback(F f);        
+    };
+
+[section:default_constructor Default Constructor]
+
+    promise();
+
+[variablelist
+
+[[Effects:] [Constructs a new __promise__ with no associated result.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:move_constructor Move Constructor]
+
+    promise(promise && other);
+
+[variablelist
+
+[[Effects:] [Constructs a new __promise__, and transfers ownership of the result associated with `other` to `*this`, leaving `other`
+with no associated result.]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:move_assignment Move Assignment Operator]
+
+    promise& operator=(promise && other);
+
+[variablelist
+
+[[Effects:] [Transfers ownership of the result associated with `other` to `*this`, leaving `other` with no associated result. If there
+was already a result associated with `*this`, and that result was not ['ready], sets any futures associated with that result to
+['ready] with a __broken_promise__ exception as the result. ]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:destructor Destructor]
+
+    ~promise();
+
+[variablelist
+
+[[Effects:] [Destroys `*this`. If there was a result associated with `*this`, and that result is not ['ready], sets any futures
+associated with that task to ['ready] with a __broken_promise__ exception as the result.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get_future Member Function `get_future()`]
+
+    unique_future<R> get_future();
+
+[variablelist
+
+[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
+`*this`. Returns a __unique_future__ associated with the result associated with `*this`. ]]
+
+[[Throws:] [__future_already_retrieved__ if the future associated with the task has already been retrieved. `std::bad_alloc` if any
+memory necessary could not be allocated.]]
+
+]
+
+[endsect]
+
+[section:set_value Member Function `set_value()`]
+
+    void set_value(R&& r);
+    void set_value(const R& r);
+    void promise<R&>::set_value(R& r);
+    void promise<void>::set_value();
+
+[variablelist
+
+[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
+`*this`. Store the value `r` in the asynchronous result associated with `*this`. Any threads blocked waiting for the asynchronous
+result are woken.]]
+
+[[Postconditions:] [All futures waiting on the asynchronous result are ['ready] and __unique_future_has_value__ or
+__shared_future_has_value__ for those futures shall return `true`.]]
+
+[[Throws:] [__promise_already_satisfied__ if the result associated with `*this` is already ['ready]. `std::bad_alloc` if the memory
+required for storage of the result cannot be allocated. Any exception thrown by the copy or move-constructor of `R`.]]
+
+]
+
+[endsect]
+
+[section:set_exception Member Function `set_exception()`]
+
+    void set_exception(boost::exception_ptr e);
+
+[variablelist
+
+[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
+`*this`. Store the exception `e` in the asynchronous result associated with `*this`. Any threads blocked waiting for the asynchronous
+result are woken.]]
+
+[[Postconditions:] [All futures waiting on the asynchronous result are ['ready] and __unique_future_has_exception__ or
+__shared_future_has_exception__ for those futures shall return `true`.]]
+
+[[Throws:] [__promise_already_satisfied__ if the result associated with `*this` is already ['ready]. `std::bad_alloc` if the memory
+required for storage of the result cannot be allocated.]]
+
+]
+
+[endsect]
+
+[section:set_wait_callback Member Function `set_wait_callback()`]
+
+    template<typename F>
+    void set_wait_callback(F f);
+
+[variablelist
+
+[[Preconditions:] [The expression `f(t)` where `t` is a lvalue of type __promise__ shall be well-formed. Invoking a copy of
+`f` shall have the same effect as invoking `f`]]
+
+[[Effects:] [Store a copy of `f` with the asynchronous result associated with `*this` as a ['wait callback]. This will replace any
+existing wait callback store alongside that result. If a thread subsequently calls one of the wait functions on a __unique_future__
+or __shared_future__ associated with this result, and the result is not ['ready], `f(*this)` shall be invoked.]]
+
+[[Throws:] [`std::bad_alloc` if memory cannot be allocated for the required storage.]]
+
+]
+
+[endsect]
+
+[endsect]
+
+[section:packaged_task `packaged_task` class template]
+
+    template<typename R>
+    class packaged_task
+    {
+        packaged_task(packaged_task&);// = delete;
+        packaged_task& operator=(packaged_task&);// = delete;
+        
+    public:
+        // construction and destruction
+        template <class F>
+        explicit packaged_task(F const& f);
+
+        explicit packaged_task(R(*f)());
+        
+        template <class F>
+        explicit packaged_task(F&& f);
+
+        // template <class F, class Allocator>
+        // explicit packaged_task(F const& f, Allocator a);
+        // template <class F, class Allocator>
+        // explicit packaged_task(F&& f, Allocator a);
+
+        ~packaged_task()
+        {}
+
+        // move support
+        packaged_task(packaged_task&& other);
+        packaged_task& operator=(packaged_task&& other);
+
+        void swap(packaged_task& other);
+        // result retrieval
+        unique_future<R> get_future();        
+
+        // execution
+        void operator()();
+
+        template<typename F>
+        void set_wait_callback(F f);        
+    };
+
+[section:task_constructor Task Constructor]
+
+    template<typename F>
+    packaged_task(F const &f);
+
+    packaged_task(R(*f)());
+
+    template<typename F>
+    packaged_task(F&&f);
+
+[variablelist
+
+[[Preconditions:] [`f()` is a valid expression with a return type convertible to `R`. Invoking a copy of `f` shall behave the same
+as invoking `f`.]]
+
+[[Effects:] [Constructs a new __packaged_task__ with a copy of `f` stored as the associated task.]]
+
+[[Throws:] [Any exceptions thrown by the copy (or move) constructor of `f`. `std::bad_alloc` if memory for the internal data
+structures could not be allocated.]]
+
+]
+
+[endsect]
+
+[section:move_constructor Move Constructor]
+
+    packaged_task(packaged_task && other);
+
+[variablelist
+
+[[Effects:] [Constructs a new __packaged_task__, and transfers ownership of the task associated with `other` to `*this`, leaving `other`
+with no associated task.]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:move_assignment Move Assignment Operator]
+
+    packaged_task& operator=(packaged_task && other);
+
+[variablelist
+
+[[Effects:] [Transfers ownership of the task associated with `other` to `*this`, leaving `other` with no associated task. If there
+was already a task associated with `*this`, and that task has not been invoked, sets any futures associated with that task to
+['ready] with a __broken_promise__ exception as the result. ]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:destructor Destructor]
+
+    ~packaged_task();
+
+[variablelist
+
+[[Effects:] [Destroys `*this`. If there was a task associated with `*this`, and that task has not been invoked, sets any futures
+associated with that task to ['ready] with a __broken_promise__ exception as the result.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get_future Member Function `get_future()`]
+
+    unique_future<R> get_future();
+
+[variablelist
+
+[[Effects:] [Returns a __unique_future__ associated with the result of the task associated with `*this`. ]]
+
+[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
+__packaged_task__. __future_already_retrieved__ if the future associated with the task has already been retrieved.]]
+
+]
+
+[endsect]
+
+[section:call_operator Member Function `operator()()`]
+
+    void operator()();
+
+[variablelist
+
+[[Effects:] [Invoke the task associated with `*this` and store the result in the corresponding future. If the task returns normally,
+the return value is stored as the asynchronous result, otherwise the exception thrown is stored. Any threads blocked waiting for the
+asynchronous result associated with this task are woken.]]
+
+[[Postconditions:] [All futures waiting on the asynchronous result are ['ready]]]
+
+[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
+__packaged_task__. __task_already_started__ if the task has already been invoked.]]
+
+]
+
+[endsect]
+
+[section:set_wait_callback Member Function `set_wait_callback()`]
+
+    template<typename F>
+    void set_wait_callback(F f);
+
+[variablelist
+
+[[Preconditions:] [The expression `f(t)` where `t` is a lvalue of type __packaged_task__ shall be well-formed. Invoking a copy of
+`f` shall have the same effect as invoking `f`]]
+
+[[Effects:] [Store a copy of `f` with the task associated with `*this` as a ['wait callback]. This will replace any existing wait
+callback store alongside that task. If a thread subsequently calls one of the wait functions on a __unique_future__ or
+__shared_future__ associated with this task, and the result of the task is not ['ready], `f(*this)` shall be invoked.]]
+
+[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
+__packaged_task__.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[section:wait_for_any Non-member function `wait_for_any()`]
+
+    template<typename Iterator>
+    Iterator wait_for_any(Iterator begin,Iterator end);
+
+    template<typename F1,typename F2>
+    unsigned wait_for_any(F1& f1,F2& f2);
+
+    template<typename F1,typename F2,typename F3>
+    unsigned wait_for_any(F1& f1,F2& f2,F3& f3);
+
+    template<typename F1,typename F2,typename F3,typename F4>
+    unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4);
+
+    template<typename F1,typename F2,typename F3,typename F4,typename F5>
+    unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5);
+
+[variablelist
+
+[[Preconditions:] [The types `Fn` shall be specializations of
+__unique_future__ or __shared_future__, and `Iterator` shall be a
+forward iterator with a `value_type` which is a specialization of
+__unique_future__ or __shared_future__.]]
+
+[[Effects:] [Waits until at least one of the specified futures is ['ready].]]
+
+[[Returns:] [The range-based overload returns an `Iterator` identifying the first future in the range that was detected as
+['ready]. The remaining overloads return the zero-based index of the first future that was detected as ['ready] (first parameter =>
+0, second parameter => 1, etc.).]]
+
+[[Throws:] [__thread_interrupted__ if the current thread is interrupted. Any exception thrown by the ['wait callback] associated
+with any of the futures being waited for.  `std::bad_alloc` if memory could not be allocated for the internal wait structures.]]
+
+[[Notes:] [`wait_for_any()` is an ['interruption point].]]
+
+]
+
+
+[endsect]
+
+[section:wait_for_all Non-member function `wait_for_all()`]
+
+    template<typename Iterator>
+    void wait_for_all(Iterator begin,Iterator end);
+
+    template<typename F1,typename F2>
+    void wait_for_all(F1& f1,F2& f2);
+
+    template<typename F1,typename F2,typename F3>
+    void wait_for_all(F1& f1,F2& f2,F3& f3);
+
+    template<typename F1,typename F2,typename F3,typename F4>
+    void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4);
+
+    template<typename F1,typename F2,typename F3,typename F4,typename F5>
+    void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5);
+
+[variablelist
+
+[[Preconditions:] [The types `Fn` shall be specializations of
+__unique_future__ or __shared_future__, and `Iterator` shall be a
+forward iterator with a `value_type` which is a specialization of
+__unique_future__ or __shared_future__.]]
+
+[[Effects:] [Waits until all of the specified futures are ['ready].]]
+
+[[Throws:] [Any exceptions thrown by a call to `wait()` on the specified futures.]]
+
+[[Notes:] [`wait_for_all()` is an ['interruption point].]]
+
+]
+
+
+[endsect]
+
+
+[endsect]
--- a/doc/futures.qbk
+++ b/doc/futures.qbk
@@ -0,0 +1,187 @@
+[/
+  (C) Copyright 2008-11 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:futures Futures]
+
+[template future_state_link[link_text] [link thread.synchronization.futures.reference.future_state [link_text]]]
+[def __uninitialized__ [future_state_link `boost::future_state::uninitialized`]]
+[def __ready__ [future_state_link `boost::future_state::ready`]]
+[def __waiting__ [future_state_link `boost::future_state::waiting`]]
+
+[def __future_uninitialized__ `boost::future_uninitialized`]
+[def __broken_promise__ `boost::broken_promise`]
+[def __future_already_retrieved__ `boost::future_already_retrieved`]
+[def __task_moved__ `boost::task_moved`]
+[def __task_already_started__ `boost::task_already_started`]
+[def __promise_already_satisfied__ `boost::promise_already_satisfied`]
+
+[def __thread_interrupted__ `boost::thread_interrupted`]
+
+
+[template unique_future_link[link_text] [link thread.synchronization.futures.reference.unique_future [link_text]]]
+[def __unique_future__ [unique_future_link `boost::unique_future`]]
+
+[template unique_future_get_link[link_text] [link thread.synchronization.futures.reference.unique_future.get [link_text]]]
+[def __unique_future_get__ [unique_future_get_link `boost::unique_future<R>::get()`]]
+
+[template unique_future_wait_link[link_text] [link thread.synchronization.futures.reference.unique_future.wait [link_text]]]
+[def __unique_future_wait__ [unique_future_wait_link `boost::unique_future<R>::wait()`]]
+
+[template unique_future_is_ready_link[link_text] [link thread.synchronization.futures.reference.unique_future.is_ready [link_text]]]
+[def __unique_future_is_ready__ [unique_future_is_ready_link `boost::unique_future<R>::is_ready()`]]
+
+[template unique_future_has_value_link[link_text] [link thread.synchronization.futures.reference.unique_future.has_value [link_text]]]
+[def __unique_future_has_value__ [unique_future_has_value_link `boost::unique_future<R>::has_value()`]]
+
+[template unique_future_has_exception_link[link_text] [link thread.synchronization.futures.reference.unique_future.has_exception [link_text]]]
+[def __unique_future_has_exception__ [unique_future_has_exception_link `boost::unique_future<R>::has_exception()`]]
+
+[template unique_future_get_state_link[link_text] [link thread.synchronization.futures.reference.unique_future.get_state [link_text]]]
+[def __unique_future_get_state__ [unique_future_get_state_link `boost::unique_future<R>::get_state()`]]
+
+[template shared_future_link[link_text] [link thread.synchronization.futures.reference.shared_future [link_text]]]
+[def __shared_future__ [shared_future_link `boost::shared_future`]]
+
+[template shared_future_get_link[link_text] [link thread.synchronization.futures.reference.shared_future.get [link_text]]]
+[def __shared_future_get__ [shared_future_get_link `boost::shared_future<R>::get()`]]
+
+[template shared_future_wait_link[link_text] [link thread.synchronization.futures.reference.shared_future.wait [link_text]]]
+[def __shared_future_wait__ [shared_future_wait_link `boost::shared_future<R>::wait()`]]
+
+[template shared_future_is_ready_link[link_text] [link thread.synchronization.futures.reference.shared_future.is_ready [link_text]]]
+[def __shared_future_is_ready__ [shared_future_is_ready_link `boost::shared_future<R>::is_ready()`]]
+
+[template shared_future_has_value_link[link_text] [link thread.synchronization.futures.reference.shared_future.has_value [link_text]]]
+[def __shared_future_has_value__ [shared_future_has_value_link `boost::shared_future<R>::has_value()`]]
+
+[template shared_future_has_exception_link[link_text] [link thread.synchronization.futures.reference.shared_future.has_exception [link_text]]]
+[def __shared_future_has_exception__ [shared_future_has_exception_link `boost::shared_future<R>::has_exception()`]]
+
+[template shared_future_get_state_link[link_text] [link thread.synchronization.futures.reference.shared_future.get_state [link_text]]]
+[def __shared_future_get_state__ [shared_future_get_state_link `boost::shared_future<R>::get_state()`]]
+
+[template promise_link[link_text] [link thread.synchronization.futures.reference.promise [link_text]]]
+[def __promise__ [promise_link `boost::promise`]]
+
+[template packaged_task_link[link_text] [link thread.synchronization.futures.reference.packaged_task [link_text]]]
+[def __packaged_task__ [packaged_task_link `boost::packaged_task`]]
+
+[template wait_for_any_link[link_text] [link thread.synchronization.futures.reference.wait_for_any [link_text]]]
+[def __wait_for_any__ [wait_for_any_link `boost::wait_for_any()`]]
+
+[template wait_for_all_link[link_text] [link thread.synchronization.futures.reference.wait_for_all [link_text]]]
+[def __wait_for_all__ [wait_for_all_link `boost::wait_for_all()`]]
+
+
+[section:overview Overview]
+
+The futures library provides a means of handling synchronous future values, whether those values are generated by another thread, or
+on a single thread in response to external stimuli, or on-demand.
+
+This is done through the provision of four class templates: __unique_future__ and __shared_future__ which are used to retrieve the
+asynchronous results, and __promise__ and __packaged_task__ which are used to generate the asynchronous results.
+
+An instance of __unique_future__ holds the one and only reference to a result. Ownership can be transferred between instances using
+the move constructor or move-assignment operator, but at most one instance holds a reference to a given asynchronous result. When
+the result is ready, it is returned from __unique_future_get__ by rvalue-reference to allow the result to be moved or copied as
+appropriate for the type.
+
+On the other hand, many instances of __shared_future__ may reference the same result. Instances can be freely copied and assigned,
+and __shared_future_get__ returns a `const` reference so that multiple calls to __shared_future_get__ are safe. You can move an
+instance of __unique_future__ into an instance of __shared_future__, thus transferring ownership of the associated asynchronous
+result, but not vice-versa.
+
+You can wait for futures either individually or with one of the __wait_for_any__ and __wait_for_all__ functions.
+
+[endsect]
+
+[section:creating Creating asynchronous values]
+
+You can set the value in a future with either a __promise__ or a __packaged_task__. A __packaged_task__ is a callable object that
+wraps a function or callable object. When the packaged task is invoked, it invokes the contained function in turn, and populates a
+future with the return value. This is an answer to the perennial question: "how do I return a value from a thread?": package the
+function you wish to run as a __packaged_task__ and pass the packaged task to the thread constructor. The future retrieved from the
+packaged task can then be used to obtain the return value. If the function throws an exception, that is stored in the future in
+place of the return value.
+
+    int calculate_the_answer_to_life_the_universe_and_everything()
+    {
+        return 42;
+    }
+
+    boost::packaged_task<int> pt(calculate_the_answer_to_life_the_universe_and_everything);
+    boost::unique_future<int> fi=pt.get_future();
+
+    boost::thread task(boost::move(pt)); // launch task on a thread
+
+    fi.wait(); // wait for it to finish
+        
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+    assert(fi.get()==42);
+
+
+A __promise__ is a bit more low level: it just provides explicit functions to store a value or an exception in the associated
+future. A promise can therefore be used where the value may come from more than one possible source, or where a single operation may
+produce multiple values.
+
+    boost::promise<int> pi;
+    boost::unique_future<int> fi;
+    fi=pi.get_future();
+
+    pi.set_value(42);
+    
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+    assert(fi.get()==42);
+
+[endsect]
+
+[section:lazy_futures Wait Callbacks and Lazy Futures]
+
+Both __promise__ and __packaged_task__ support ['wait callbacks] that are invoked when a thread blocks in a call to `wait()` or
+`timed_wait()` on a future that is waiting for the result from the __promise__ or __packaged_task__, in the thread that is doing the
+waiting. These can be set using the `set_wait_callback()` member function on the __promise__ or __packaged_task__ in question.
+
+This allows ['lazy futures] where the result is not actually computed until it is needed by some thread. In the example below, the
+call to `f.get()` invokes the callback `invoke_lazy_task`, which runs the task to set the value. If you remove the call to
+`f.get()`, the task is not ever run.
+
+    int calculate_the_answer_to_life_the_universe_and_everything()
+    {
+        return 42;
+    }
+
+    void invoke_lazy_task(boost::packaged_task<int>& task)
+    {
+        try
+        {
+            task();
+        }
+        catch(boost::task_already_started&)
+        {}
+    }
+
+    int main()
+    {
+        boost::packaged_task<int> task(calculate_the_answer_to_life_the_universe_and_everything);
+        task.set_wait_callback(invoke_lazy_task);
+        boost::unique_future<int> f(task.get_future());
+
+        assert(f.get()==42);
+    }
+
+
+[endsect]
+
+[include future_ref.qbk]
+
+[endsect]
--- a/doc/mutex_concepts.qbk
+++ b/doc/mutex_concepts.qbk
@@ -1,3 +1,11 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  (C) Copyright 2011-12 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).
+]
+
 [section:mutex_concepts Mutex Concepts]

 A mutex object facilitates protection against data races and allows thread-safe synchronization of data between threads. A thread
@@ -31,6 +39,16 @@ Lock ownership acquired through a call to __lock_ref__ or __try_lock_ref__ must

 [[Throws:] [__thread_resource_error__ if an error occurs.]]

+[[Error Conditions:] [
+
+[*operation_not_permitted]: if the thread does not have the privilege to perform the operation.
+
+[*resource_deadlock_would_occur]:  if the implementation detects that a deadlock would occur.
+
+[*device_or_resource_busy]: if the mutex is already locked and blocking is not possible.
+
+]]
+
 ]
 [endsect]

@@ -44,7 +62,7 @@ Lock ownership acquired through a call to __lock_ref__ or __try_lock_ref__ must

 [[Postcondition:] [If the call returns `true`, the current thread owns the `*this`.]]

-[[Throws:] [__thread_resource_error__ if an error occurs.]]
+[[Throws:] [Nothing.]]

 ]
 [endsect]
@@ -59,7 +77,7 @@ Lock ownership acquired through a call to __lock_ref__ or __try_lock_ref__ must

 [[Postcondition:] [The current thread no longer owns `*this`.]]

-[[Throws:] [Nothing]]
+[[Throws:] [Nothing.]]
 ]
 [endsect]
 [endsect]
@@ -73,12 +91,17 @@ A type that implements the __timed_lockable_concept__ shall meet the requirement
 of the __lockable_concept__. In addition, the following member functions must be
 provided:

-* [timed_lock_ref_link `bool timed_lock(boost::system_time const& abs_time);`]
-* [timed_lock_duration_ref_link `template<typename DurationType> bool timed_lock(DurationType const& rel_time);`]
+* [timed_lock_ref_link `bool timed_lock(boost::system_time const& abs_time);` DEPRECATED V2]
+* [timed_lock_duration_ref_link `template<typename DurationType> bool timed_lock(DurationType const& rel_time);` DEPRECATED V2]

-Lock ownership acquired through a call to __timed_lock_ref__ must be released through a call to __unlock_ref__.
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& t);

-[section:timed_lock `bool timed_lock(boost::system_time const& abs_time)`]
+Lock ownership acquired through a call to __timed_lock_ref__, __try_lock_for or __try_lock_until must be released through a call to __unlock_ref__.
+
+[section:timed_lock `bool timed_lock(boost::system_time const& abs_time)` DEPRECATED V2]

 [variablelist

@@ -94,7 +117,7 @@ reached. If the specified time has already passed, behaves as __try_lock_ref__.]
 [endsect]

 [section:timed_lock_duration `template<typename DurationType> bool
-timed_lock(DurationType const& rel_time)`]
+timed_lock(DurationType const& rel_time)` DEPRECATED V2]

 [variablelist

@@ -104,6 +127,32 @@ timed_lock(DurationType const& rel_time)`]
 ]
 [endsect]

+[section:try_lock_until `template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)`]
+
+[variablelist
+
+[[Effects:] [Attempt to obtain ownership for the current thread. Blocks until ownership can be obtained, or the specified time is
+reached. If the specified time has already passed, behaves as __try_lock_ref__.]]
+
+[[Returns:] [`true` if ownership was obtained for the current thread, `false` otherwise.]]
+
+[[Postcondition:] [If the call returns `true`, the current thread owns `*this`.]]
+
+[[Throws:] [Nothing.]]
+]
+[endsect]
+
+[section:try_lock_for `template <class Rep, class Period> bool
+try_lock_for(const chrono::duration<Rep, Period>& rel_time)`]
+
+[variablelist
+
+[[Effects:] [As-if `__try_lock_until(chrono::steady_clock::now() + rel_time)`.]]
+
+]
+[endsect]
+
+
 [endsect]

 [section:shared_lockable `SharedLockable` Concept]
@@ -303,8 +352,29 @@ without blocking.]]

 [section:locks Lock Types]

+[section:lock_tags Lock option tags] 
+
+  #include <boost/thread/locks.hpp> 
+
+  struct defer_lock_t {}; 
+  struct try_to_lock_t {}; 
+  struct adopt_lock_t {}; 
+  const defer_lock_t defer_lock; 
+  const try_to_lock_t try_to_lock; 
+  const adopt_lock_t adopt_lock; 
+
+These tags are used in scoped locks constructors to specify a specific behavior. 
+
+*`defer_lock_t`: is used to construct the scoped lock without locking it. 
+*`try_to_lock_t`: is used to construct the scoped lock trying to lock it. 
+*`adopt_lock_t`: is used to construct the scoped lock without locking it but adopting ownership. 
+
+[endsect] 
+
 [section:lock_guard Class template `lock_guard`]

+    #include <boost/thread/locks.hpp>
+
    template<typename Lockable>
    class lock_guard
    {
@@ -369,45 +439,59 @@ object passed to the constructor.]]

 [section:unique_lock Class template `unique_lock`]

+    #include <boost/thread/locks.hpp>
+
    template<typename Lockable>
    class unique_lock
    {
    public:
-        unique_lock();
+        typedef Lockable mutex_type;
+        unique_lock() noexcept;
        explicit unique_lock(Lockable& m_);
        unique_lock(Lockable& m_,adopt_lock_t);
-        unique_lock(Lockable& m_,defer_lock_t);
+        unique_lock(Lockable& m_,defer_lock_t) noexcept;
        unique_lock(Lockable& m_,try_to_lock_t);
-        unique_lock(Lockable& m_,system_time const& target_time);
+        unique_lock(Lockable& m_,system_time const& target_time); // DEPRECATED V2

+        template <class Clock, class Duration>
+        unique_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t);
+        template <class Rep, class Period>
+        unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d);
        ~unique_lock();

-        unique_lock(detail::thread_move_t<unique_lock<Lockable> > other);
-        unique_lock(detail::thread_move_t<upgrade_lock<Lockable> > other);
+        unique_lock(unique_lock const&) = delete;
+        unique_lock& operator=(unique_lock const&) = delete;
+        unique_lock(unique_lock<Lockable>&& other) noexcept;
+        unique_lock(upgrade_lock<Lockable>&& other) noexcept;

-        operator detail::thread_move_t<unique_lock<Lockable> >();
-        detail::thread_move_t<unique_lock<Lockable> > move();
-        unique_lock& operator=(detail::thread_move_t<unique_lock<Lockable> > other);
-        unique_lock& operator=(detail::thread_move_t<upgrade_lock<Lockable> > other);
+        unique_lock& operator=(unique_lock<Lockable>&& other) noexcept;
+        unique_lock& operator=(upgrade_lock<Lockable>&& other) noexcept;

-        void swap(unique_lock& other);
-        void swap(detail::thread_move_t<unique_lock<Lockable> > other);
+        void swap(unique_lock& other) noexcept;
+        Lockable* release() noexcept;

        void lock();
        bool try_lock();

        template<typename TimeDuration>
-        bool timed_lock(TimeDuration const& relative_time);
-        bool timed_lock(::boost::system_time const& absolute_time);
+        bool timed_lock(TimeDuration const& relative_time); // DEPRECATED V2
+        bool timed_lock(::boost::system_time const& absolute_time); // DEPRECATED V2
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);

        void unlock();

-        bool owns_lock() const;
-        operator ``['unspecified-bool-type]``() const;
-        bool operator!() const;
+        bool owns_lock() const noexcept;
+    #if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
+        operator ``['unspecified-bool-type]``() const noexcept;
+        bool operator!() const noexcept;
+    #else
+        explicit operator bool() const noexcept;
+    #endif

-        Lockable* mutex() const;
-        Lockable* release();
+        Lockable* mutex() const noexcept;
    };

 __unique_lock__ is more complex than __lock_guard__: not only does it provide for RAII-style locking, it also allows for deferring
@@ -415,7 +499,7 @@ acquiring the lock until the __lock_ref__ member function is called explicitly,
 fashion, or with a timeout. Consequently, __unlock_ref__ is only called in the destructor if the lock object has locked the
 __lockable_concept_type__ object, or otherwise adopted a lock on the __lockable_concept_type__ object.

-Specializations of __unique_lock__ model the __timed_lockable_concept__ if the supplied __lockable_concept_type__ type itself models
+Specializations of __unique_lock__ model the __timed_lockable_concept__ if the supplied Lockable type itself models
 __timed_lockable_concept__ (e.g. `boost::unique_lock<boost::timed_mutex>`), or the __lockable_concept__ otherwise
 (e.g. `boost::unique_lock<boost::mutex>`). 

@@ -503,7 +587,7 @@ returns `false`.]]

 [endsect]

-[section:constructor_abs_time `unique_lock(Lockable & m,boost::system_time const& abs_time)`]
+[section:constructor_abs_time `unique_lock(Lockable & m,boost::system_time const& abs_time)`  // DEPRECATED V2]

 [variablelist

@@ -521,6 +605,47 @@ returns `false`.]]

 [endsect]

+[section:constructor_time_point `template <class Clock, class Duration> unique_lock(Lockable & m,const chrono::time_point<Clock, Duration>& abs_time)`]
+
+        template <class Rep, class Period>
+        unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d);
+
+
+[variablelist
+
+[[Effects:] [Stores a reference to `m`. Invokes 
+`m.__try_lock_until(abs_time)`, and takes ownership of the lock state if the call
+returns `true`.]]
+
+[[Postcondition:] [__mutex_func_ref__ returns `&m`. If the call to __try_lock_until
+returned `true`, then __owns_lock_ref__ returns `true`, otherwise __owns_lock_ref__
+returns `false`.]]
+
+[[Throws:] [Any exceptions thrown by the call to `m.__try_lock_until(abs_time)`.]]
+
+]
+
+[endsect]
+
+[section:constructor_duration `template <class Rep, class Period> unique_lock(Lockable & m,const chrono::duration<Rep, Period>& abs_time)`]
+
+
+[variablelist
+
+[[Effects:] [Stores a reference to `m`. Invokes 
+`m.__try_lock_for(rel_time)`, and takes ownership of the lock state if the call
+returns `true`.]]
+
+[[Postcondition:] [__mutex_func_ref__ returns `&m`. If the call to __try_lock_for
+returned `true`, then __owns_lock_ref__ returns `true`, otherwise __owns_lock_ref__
+returns `false`.]]
+
+[[Throws:] [Any exceptions thrown by the call to `m.__try_lock_for(rel_time)`.]]
+
+]
+
+[endsect]
+
 [section:destructor `~unique_lock()`]

 [variablelist
@@ -560,6 +685,18 @@ object associated with `*this`.]]

 [endsect]

+[section:explicit_bool_conversion `explicit operator bool() const`]
+
+[variablelist
+
+[[Returns:] [`__owns_lock_ref__()`.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
 [section:bool_conversion `operator unspecified-bool-type() const`]

 [variablelist
@@ -574,6 +711,7 @@ boolean contexts.]]

 [endsect]

+
 [section:operator_not `bool operator!() const`]

 [variablelist
@@ -610,28 +748,31 @@ __owns_lock_ref__ returns `false`.]]

 [section:shared_lock Class template `shared_lock`]

+    #include <boost/thread/locks.hpp>
+
    template<typename Lockable>
    class shared_lock
    {
    public:
+        typedef Lockable mutex_type;
        shared_lock();
        explicit shared_lock(Lockable& m_);
        shared_lock(Lockable& m_,adopt_lock_t);
        shared_lock(Lockable& m_,defer_lock_t);
        shared_lock(Lockable& m_,try_to_lock_t);
        shared_lock(Lockable& m_,system_time const& target_time);
-        shared_lock(detail::thread_move_t<shared_lock<Lockable> > other);
-        shared_lock(detail::thread_move_t<unique_lock<Lockable> > other);
-        shared_lock(detail::thread_move_t<upgrade_lock<Lockable> > other);
-
        ~shared_lock();

-        operator detail::thread_move_t<shared_lock<Lockable> >();
-        detail::thread_move_t<shared_lock<Lockable> > move();
+        shared_lock(shared_lock const&) = delete;
+        shared_lock& operator=(shared_lock const&) = delete;

-        shared_lock& operator=(detail::thread_move_t<shared_lock<Lockable> > other);
-        shared_lock& operator=(detail::thread_move_t<unique_lock<Lockable> > other);
-        shared_lock& operator=(detail::thread_move_t<upgrade_lock<Lockable> > other);
+        shared_lock(shared_lock<Lockable> && other);
+        shared_lock(unique_lock<Lockable> && other);
+        shared_lock(upgrade_lock<Lockable> && other);
+
+        shared_lock& operator=(shared_lock<Lockable> && other);
+        shared_lock& operator=(unique_lock<Lockable> && other);
+        shared_lock& operator=(upgrade_lock<Lockable> && other);
        void swap(shared_lock& other);

        void lock();
@@ -639,8 +780,12 @@ __owns_lock_ref__ returns `false`.]]
        bool timed_lock(boost::system_time const& target_time);
        void unlock();

+    #if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
        operator ``['unspecified-bool-type]``() const;
        bool operator!() const;
+    #else
+        explicit operator bool() const;
+    #endif
        bool owns_lock() const;
    };

@@ -819,6 +964,18 @@ boolean contexts.]]

 [endsect]

+[section:explicit_operator_bool `explicit operator bool() const`]
+
+[variablelist
+
+[[Returns:] [__owns_lock_shared_ref__.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
 [section:release `Lockable* release()`]

 [variablelist
@@ -843,30 +1000,37 @@ __owns_lock_shared_ref__ returns `false`.]]

 [section:upgrade_lock Class template `upgrade_lock`]

+    #include <boost/thread/locks.hpp>
+
    template<typename Lockable>
    class upgrade_lock
    {
    public:
+        typedef Lockable mutex_type;
        explicit upgrade_lock(Lockable& m_);

-        upgrade_lock(detail::thread_move_t<upgrade_lock<Lockable> > other);
-        upgrade_lock(detail::thread_move_t<unique_lock<Lockable> > other);
+        upgrade_lock(upgrade_lock<Lockable> && other);
+        upgrade_lock(unique_lock<Lockable> && other);

        ~upgrade_lock();

-        operator detail::thread_move_t<upgrade_lock<Lockable> >();
-        detail::thread_move_t<upgrade_lock<Lockable> > move();
+        upgrade_lock(const upgrade_lock& other) = delete;
+        upgrade_lock& operator=(const upgrade_lock<Lockable> & other) = delete;

-        upgrade_lock& operator=(detail::thread_move_t<upgrade_lock<Lockable> > other);
-        upgrade_lock& operator=(detail::thread_move_t<unique_lock<Lockable> > other);
+        upgrade_lock& operator=(upgrade_lock<Lockable> && other);
+        upgrade_lock& operator=(unique_lock<Lockable> && other);

        void swap(upgrade_lock& other);

        void lock();
        void unlock();

+    #if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
        operator ``['unspecified-bool-type]``() const;
        bool operator!() const;
+    #else
+        explicit operator bool() const;
+    #endif
        bool owns_lock() const;
    };

@@ -890,20 +1054,30 @@ state (including the destructor) must be called by the same thread that acquired

 [section:upgrade_to_unique_lock Class template `upgrade_to_unique_lock`]

+    #include <boost/thread/locks.hpp>
+
    template <class Lockable>
    class upgrade_to_unique_lock
    {
    public:
+        typedef Lockable mutex_type;
        explicit upgrade_to_unique_lock(upgrade_lock<Lockable>& m_);
-
        ~upgrade_to_unique_lock();

-        upgrade_to_unique_lock(detail::thread_move_t<upgrade_to_unique_lock<Lockable> > other);
-        upgrade_to_unique_lock& operator=(detail::thread_move_t<upgrade_to_unique_lock<Lockable> > other);
+        upgrade_to_unique_lock(upgrade_to_unique_lock const& other) = delete;
+        upgrade_to_unique_lock& operator=(upgrade_to_unique_lock<Lockable> const& other) = delete;
+
+        upgrade_to_unique_lock(upgrade_to_unique_lock<Lockable> && other);
+        upgrade_to_unique_lock& operator=(upgrade_to_unique_lock<Lockable> && other);
+
        void swap(upgrade_to_unique_lock& other);

+    #if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
        operator ``['unspecified-bool-type]``() const;
        bool operator!() const;
+    #else
+        explicit operator bool() const;
+    #endif
        bool owns_lock() const;
    };

@@ -914,4 +1088,192 @@ __lockable_concept_type__ is downgraded back to ['upgrade ownership].

 [endsect]

+[section:scoped_try_lock Mutex-specific class `scoped_try_lock`]
+
+    class MutexType::scoped_try_lock
+    {
+    private:
+        MutexType::scoped_try_lock(MutexType::scoped_try_lock<MutexType>& other);
+        MutexType::scoped_try_lock& operator=(MutexType::scoped_try_lock<MutexType>& other);
+    public:
+        MutexType::scoped_try_lock();
+        explicit MutexType::scoped_try_lock(MutexType& m);
+        MutexType::scoped_try_lock(MutexType& m_,adopt_lock_t);
+        MutexType::scoped_try_lock(MutexType& m_,defer_lock_t);
+        MutexType::scoped_try_lock(MutexType& m_,try_to_lock_t);
+
+        MutexType::scoped_try_lock(MutexType::scoped_try_lock<MutexType>&& other);
+        MutexType::scoped_try_lock& operator=(MutexType::scoped_try_lock<MutexType>&& other);
+
+        void swap(MutexType::scoped_try_lock&& other);
+
+        void lock();
+        bool try_lock();
+        void unlock();
+        bool owns_lock() const;
+
+        MutexType* mutex() const;
+        MutexType* release();
+
+    #if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
+        operator ``['unspecified-bool-type]``() const;
+        bool operator!() const;
+    #else
+        explicit operator bool() const;
+    #endif
+    };
+
+The member typedef `scoped_try_lock` is provided for each distinct
+`MutexType` as a typedef to a class with the preceding definition. The
+semantics of each constructor and member function are identical to
+those of [unique_lock_link `boost::unique_lock<MutexType>`] for the same `MutexType`, except
+that the constructor that takes a single reference to a mutex will
+call [try_lock_ref_link `m.try_lock()`] rather than `m.lock()`.
+
+
+[endsect]
+
+[endsect]
+
+[section:lock_functions Lock functions]
+
+[section:lock_multiple Non-member function `lock(Lockable1,Lockable2,...)`]
+
+    template<typename Lockable1,typename Lockable2>
+    void lock(Lockable1& l1,Lockable2& l2);
+
+    template<typename Lockable1,typename Lockable2,typename Lockable3>
+    void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3);
+
+    template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4>
+    void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4);
+
+    template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4,typename Lockable5>
+    void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4,Lockable5& l5);
+
+[variablelist
+
+[[Effects:] [Locks the __lockable_concept_type__ objects supplied as
+arguments in an unspecified and indeterminate order in a way that
+avoids deadlock. It is safe to call this function concurrently from
+multiple threads with the same mutexes (or other lockable objects) in
+different orders without risk of deadlock. If any of the __lock_ref__
+or __try_lock_ref__ operations on the supplied
+__lockable_concept_type__ objects throws an exception any locks
+acquired by the function will be released before the function exits.]]
+
+[[Throws:] [Any exceptions thrown by calling __lock_ref__ or
+__try_lock_ref__ on the supplied __lockable_concept_type__ objects.]]
+
+[[Postcondition:] [All the supplied __lockable_concept_type__ objects
+are locked by the calling thread.]]
+
+]
+
+[endsect]
+
+[section:lock_range Non-member function `lock(begin,end)`]
+
+    template<typename ForwardIterator>
+    void lock(ForwardIterator begin,ForwardIterator end);
+
+[variablelist
+
+[[Preconditions:] [The `value_type` of `ForwardIterator` must implement the __lockable_concept__]]
+
+[[Effects:] [Locks all the __lockable_concept_type__ objects in the
+supplied range in an unspecified and indeterminate order in a way that
+avoids deadlock. It is safe to call this function concurrently from
+multiple threads with the same mutexes (or other lockable objects) in
+different orders without risk of deadlock. If any of the __lock_ref__
+or __try_lock_ref__ operations on the __lockable_concept_type__
+objects in the supplied range throws an exception any locks acquired
+by the function will be released before the function exits.]]
+
+[[Throws:] [Any exceptions thrown by calling __lock_ref__ or
+__try_lock_ref__ on the supplied __lockable_concept_type__ objects.]]
+
+[[Postcondition:] [All the __lockable_concept_type__ objects in the
+supplied range are locked by the calling thread.]]
+
+]
+
+[endsect]
+
+[section:try_lock_multiple Non-member function `try_lock(Lockable1,Lockable2,...)`]
+
+    template<typename Lockable1,typename Lockable2>
+    int try_lock(Lockable1& l1,Lockable2& l2);
+
+    template<typename Lockable1,typename Lockable2,typename Lockable3>
+    int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3);
+
+    template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4>
+    int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4);
+
+    template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4,typename Lockable5>
+    int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4,Lockable5& l5);
+
+[variablelist
+
+[[Effects:] [Calls __try_lock_ref__ on each of the
+__lockable_concept_type__ objects supplied as arguments. If any of the
+calls to __try_lock_ref__ returns `false` then all locks acquired are
+released and the zero-based index of the failed lock is returned.
+
+If any of the __try_lock_ref__ operations on the supplied
+__lockable_concept_type__ objects throws an exception any locks
+acquired by the function will be released before the function exits.]]
+
+[[Returns:] [`-1` if all the supplied __lockable_concept_type__ objects
+are now locked by the calling thread, the zero-based index of the
+object which could not be locked otherwise.]]
+
+[[Throws:] [Any exceptions thrown by calling __try_lock_ref__ on the
+supplied __lockable_concept_type__ objects.]]
+
+[[Postcondition:] [If the function returns `-1`, all the supplied
+__lockable_concept_type__ objects are locked by the calling
+thread. Otherwise any locks acquired by this function will have been
+released.]]
+
+]
+
+[endsect]
+
+[section:try_lock_range Non-member function `try_lock(begin,end)`]
+
+    template<typename ForwardIterator>
+    ForwardIterator try_lock(ForwardIterator begin,ForwardIterator end);
+
+[variablelist
+
+[[Preconditions:] [The `value_type` of `ForwardIterator` must implement the __lockable_concept__]]
+
+[[Effects:] [Calls __try_lock_ref__ on each of the
+__lockable_concept_type__ objects in the supplied range. If any of the
+calls to __try_lock_ref__ returns `false` then all locks acquired are
+released and an iterator referencing the failed lock is returned.
+
+If any of the __try_lock_ref__ operations on the supplied
+__lockable_concept_type__ objects throws an exception any locks
+acquired by the function will be released before the function exits.]]
+
+[[Returns:] [`end` if all the supplied __lockable_concept_type__
+objects are now locked by the calling thread, an iterator referencing
+the object which could not be locked otherwise.]]
+
+[[Throws:] [Any exceptions thrown by calling __try_lock_ref__ on the
+supplied __lockable_concept_type__ objects.]]
+
+[[Postcondition:] [If the function returns `end` then all the
+__lockable_concept_type__ objects in the supplied range are locked by
+the calling thread, otherwise all locks acquired by the function have
+been released.]]
+
+]
+
+[endsect]
+
+
 [endsect]
--- a/doc/mutexes.qbk
+++ b/doc/mutexes.qbk
@@ -1,7 +1,17 @@
+[/
+  (C) Copyright 2007-11 Anthony Williams
+  (C) Copyright 2011-12 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).
+]
+
 [section:mutex_types Mutex Types]

 [section:mutex Class `mutex`]

+    #include <boost/thread/mutex.hpp>
+
    class mutex:
        boost::noncopyable
    {
@@ -17,7 +27,7 @@
        native_handle_type native_handle();
        
        typedef unique_lock<mutex> scoped_lock;
-        typedef scoped_lock scoped_try_lock;
+        typedef unspecified-type scoped_try_lock;
    };

 __mutex__ implements the __lockable_concept__ to provide an exclusive-ownership mutex. At most one thread can own the lock on a given
@@ -44,6 +54,8 @@ implementation. If no such instance exists, `native_handle()` and `native_handle

 [section:try_mutex Typedef `try_mutex`]

+    #include <boost/thread/mutex.hpp>
+
    typedef mutex try_mutex;

 __try_mutex__ is a `typedef` to __mutex__, provided for backwards compatibility with previous releases of boost.
@@ -52,6 +64,8 @@ __try_mutex__ is a `typedef` to __mutex__, provided for backwards compatibility

 [section:timed_mutex Class `timed_mutex`]

+    #include <boost/thread/mutex.hpp>
+
    class timed_mutex:
        boost::noncopyable
    {
@@ -62,16 +76,20 @@ __try_mutex__ is a `typedef` to __mutex__, provided for backwards compatibility
        void lock();
        void unlock();
        bool try_lock();
-        bool timed_lock(system_time const & abs_time);
-
+        bool timed_lock(system_time const & abs_time); // DEPRECATED V2
        template<typename TimeDuration>
-        bool timed_lock(TimeDuration const & relative_time);
+        bool timed_lock(TimeDuration const & relative_time); // DEPRECATED V2
+
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& t);

        typedef platform-specific-type native_handle_type;
        native_handle_type native_handle();

        typedef unique_lock<timed_mutex> scoped_timed_lock;
-        typedef scoped_timed_lock scoped_try_lock;
+        typedef unspecified-type scoped_try_lock;
        typedef scoped_timed_lock scoped_lock;
    };

@@ -99,6 +117,8 @@ implementation. If no such instance exists, `native_handle()` and `native_handle

 [section:recursive_mutex Class `recursive_mutex`]

+    #include <boost/thread/recursive_mutex.hpp>
+
    class recursive_mutex:
        boost::noncopyable
    {
@@ -114,7 +134,7 @@ implementation. If no such instance exists, `native_handle()` and `native_handle
        native_handle_type native_handle();
        
        typedef unique_lock<recursive_mutex> scoped_lock;
-        typedef scoped_lock scoped_try_lock;
+        typedef unspecified-type scoped_try_lock;
    };

 __recursive_mutex__ implements the __lockable_concept__ to provide an exclusive-ownership recursive mutex. At most one thread can
@@ -143,6 +163,8 @@ implementation. If no such instance exists, `native_handle()` and `native_handle

 [section:recursive_try_mutex Typedef `recursive_try_mutex`]

+    #include <boost/thread/recursive_mutex.hpp>
+
    typedef recursive_mutex recursive_try_mutex;

 __recursive_try_mutex__ is a `typedef` to __recursive_mutex__, provided for backwards compatibility with previous releases of boost.
@@ -151,6 +173,8 @@ __recursive_try_mutex__ is a `typedef` to __recursive_mutex__, provided for back

 [section:recursive_timed_mutex Class `recursive_timed_mutex`]

+    #include <boost/thread/recursive_mutex.hpp>
+
    class recursive_timed_mutex:
        boost::noncopyable
    {
@@ -162,16 +186,20 @@ __recursive_try_mutex__ is a `typedef` to __recursive_mutex__, provided for back
        bool try_lock();
        void unlock();

-        bool timed_lock(system_time const & abs_time);
-
+        bool timed_lock(system_time const & abs_time); // DEPRECATED V2 
        template<typename TimeDuration>
-        bool timed_lock(TimeDuration const & relative_time);
+        bool timed_lock(TimeDuration const & relative_time); // DEPRECATED V2
+
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& t);

        typedef platform-specific-type native_handle_type;
        native_handle_type native_handle();
        
        typedef unique_lock<recursive_timed_mutex> scoped_lock;
-        typedef scoped_lock scoped_try_lock;
+        typedef unspecified-type scoped_try_lock;
        typedef scoped_lock scoped_timed_lock;
    };

--- a/doc/once.qbk
+++ b/doc/once.qbk
@@ -1,9 +1,18 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
 [section:once One-time Initialization]

 `boost::call_once` provides a mechanism for ensuring that an initialization routine is run exactly once without data races or deadlocks.

 [section:once_flag Typedef `once_flag`]

+    #include <boost/thread/once.hpp>
+
    typedef platform-specific-type once_flag;
    #define BOOST_ONCE_INIT platform-specific-initializer

@@ -15,6 +24,8 @@ Objects of type `boost::once_flag` shall be initialized with `BOOST_ONCE_INIT`:

 [section:call_once Non-member function `call_once`]

+    #include <boost/thread/once.hpp>
+
    template<typename Callable>
    void call_once(once_flag& flag,Callable func);

@@ -24,8 +35,8 @@ Objects of type `boost::once_flag` shall be initialized with `BOOST_ONCE_INIT`:
 be equivalent to calling the original. ]]

 [[Effects:] [Calls to `call_once` on the same `once_flag` object are serialized. If there has been no prior effective `call_once` on
-the same `once_flag` object, the argument `func` (or a copy thereof) is called as-if by invoking `func(args)`, and the invocation of
-`call_once` is effective if and only if `func(args)` returns without exception. If an exception is thrown, the exception is
+the same `once_flag` object, the argument `func` (or a copy thereof) is called as-if by invoking `func()`, and the invocation of
+`call_once` is effective if and only if `func()` returns without exception. If an exception is thrown, the exception is
 propagated to the caller. If there has been a prior effective `call_once` on the same `once_flag` object, the `call_once` returns
 without invoking `func`. ]]

@@ -34,6 +45,15 @@ all subsequent `call_once` invocations on the same `once_flag` object. ]]

 [[Throws:] [`thread_resource_error` when the effects cannot be achieved. or any exception propagated from `func`.]]

+[[Note:] [The function passed to `call_once` must not also call
+`call_once` passing the same `once_flag` object. This may cause
+deadlock, or invoking the passed function a second time. The
+alternative is to allow the second call to return immediately, but
+that assumes the code knows it has been called recursively, and can
+proceed even though the call to `call_once` didn't actually call the
+function, in which case it could also avoid calling `call_once`
+recursively.]]
+
 ]

    void call_once(void (*func)(),once_flag& flag);
--- a/doc/overview.qbk
+++ b/doc/overview.qbk
@@ -1,15 +1,44 @@
+[/
+  (C) Copyright 2007-12 Anthony Williams.
+  (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).
+]
+
 [section:overview Overview]

 __boost_thread__ enables the use of multiple threads of execution with shared data in portable C++ code. It provides classes and
 functions for managing the threads themselves, along with others for synchronizing data between the threads or providing separate
 copies of data specific to individual threads.

-The __boost_thread__ library was originally written and designed by William E. Kempf. This version is a major rewrite designed to
+The __boost_thread__ library was originally written and designed by William E. Kempf (version 0). Anthony Williams version (version 1) was a major rewrite designed to
 closely follow the proposals presented to the C++ Standards Committee, in particular
 [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2497.html N2497],
 [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2320.html N2320],
 [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2184.html N2184], 
 [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2139.html N2139], and 
 [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2094.html N2094]
+Vicente J. Botet Escriba started in version 2 the adaptation to comply with the accepted Thread C++11 library.
+
+In order to use the classes and functions described here, you can
+either include the specific headers specified by the descriptions of
+each class or function, or include the master thread library header:
+
+    #include <boost/thread.hpp>
+
+which includes all the other headers in turn.

 [endsect]
+
+
+[section:build Using and building the library]
+
+Boost.Thread is configured following the conventions used to build [@http://www.boost.org/doc/libs/1_48_0/libs/config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_for_libraries_with_separate_source_code libraries with separate source code]. Boost.Thread will import/export the code only if the user has specifically asked for it, by defining either BOOST_ALL_DYN_LINK if they want all boost libraries to be dynamically linked, or BOOST_THREAD_DYN_LINK if they want just this one to be dynamically liked.
+
+The definition of these macros determines whether BOOST_THREAD_USE_DLL is defined. If  BOOST_THREAD_USE_DLL is not defined, the library will define BOOST_THREAD_USE_DLL or BOOST_THREAD_USE_LIB depending on whether the platform. On non windows platforms BOOST_THREAD_USE_LIB is defined if is not defined. In windows platforms, BOOST_THREAD_USE_LIB is defined if BOOST_THREAD_USE_DLL and the compiler supports auto-tss cleanup with Boost.Threads (for the time been Msvc and Intel)
+
+The source code compiled when building the library defines a macros BOOST_THREAD_SOURCE that is used to import or export it. The user must not define this macro in any case. 
+
+[endsect]
+
--- a/doc/shared_mutex_ref.qbk
+++ b/doc/shared_mutex_ref.qbk
@@ -1,5 +1,14 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
 [section:shared_mutex Class `shared_mutex`]

+    #include <boost/thread/shared_mutex.hpp>
+
    class shared_mutex
    {
    public:
--- a/doc/thread.qbk
+++ b/doc/thread.qbk
@@ -1,7 +1,16 @@
+[/
+  (C) Copyright 2008-11 Anthony Williams
+  (C) Copyright 2011-12 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).
+]
+
 [article Thread
-    [quickbook 1.4]
-    [authors [Williams, Anthony]]
-    [copyright 2007-8 Anthony Williams]
+    [quickbook 1.5]
+    [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
+    [copyright 2007-11 Anthony Williams]
+    [copyright 2011-12 Vicente J. Botet Escriba]
    [purpose C++ Library for launching threads and synchronizing data between them]
    [category text]
    [license
@@ -31,6 +40,12 @@
 [template lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.lockable.lock [link_text]]]
 [def __lock_ref__ [lock_ref_link `lock()`]]

+[template lock_multiple_ref_link[link_text] [link thread.synchronization.lock_functions.lock_multiple [link_text]]]
+[def __lock_multiple_ref__ [lock_multiple_ref_link `lock()`]]
+
+[template try_lock_multiple_ref_link[link_text] [link thread.synchronization.lock_functions.try_lock_multiple [link_text]]]
+[def __try_lock_multiple_ref__ [try_lock_multiple_ref_link `try_lock()`]]
+
 [template unlock_ref_link[link_text] [link thread.synchronization.mutex_concepts.lockable.unlock [link_text]]]
 [def __unlock_ref__ [unlock_ref_link `unlock()`]]

@@ -40,6 +55,9 @@
 [template timed_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock [link_text]]]
 [def __timed_lock_ref__ [timed_lock_ref_link `timed_lock()`]]

+[def __try_lock_for [link thread.synchronization.mutex_concepts.timed_lockable.try_lock_for `try_lock_for`]]
+[def __try_lock_until [link thread.synchronization.mutex_concepts.timed_lockable.try_lock_until `try_lock_until`]]
+
 [template timed_lock_duration_ref_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock_duration [link_text]]]
 [def __timed_lock_duration_ref__ [timed_lock_duration_ref_link `timed_lock()`]]

@@ -94,22 +112,32 @@
 [def __recursive_timed_mutex__ [link thread.synchronization.mutex_types.recursive_timed_mutex `boost::recursive_timed_mutex`]]
 [def __shared_mutex__ [link thread.synchronization.mutex_types.shared_mutex `boost::shared_mutex`]]

+[template unique_lock_link[link_text] [link thread.synchronization.locks.unique_lock [link_text]]]
+
 [def __lock_guard__ [link thread.synchronization.locks.lock_guard `boost::lock_guard`]]
-[def __unique_lock__ [link thread.synchronization.locks.unique_lock `boost::unique_lock`]]
+[def __unique_lock__ [unique_lock_link `boost::unique_lock`]]
 [def __shared_lock__ [link thread.synchronization.locks.shared_lock `boost::shared_lock`]]
 [def __upgrade_lock__ [link thread.synchronization.locks.upgrade_lock `boost::upgrade_lock`]]
 [def __upgrade_to_unique_lock__ [link thread.synchronization.locks.upgrade_to_unique_lock `boost::upgrade_to_unique_lock`]]


 [def __thread__ [link thread.thread_management.thread `boost::thread`]]
+[def __thread [link thread.thread_management.thread `boost::thread`]]
 [def __thread_id__ [link thread.thread_management.thread.id `boost::thread::id`]]
 [template join_link[link_text] [link thread.thread_management.thread.join [link_text]]]
 [def __join__ [join_link `join()`]]
+
+[def __try_join_for [link thread.thread_management.thread.try_join_for `try_join_for`]]
+[def __try_join_until [link thread.thread_management.thread.try_join_until `try_join_until`]]
+
+
 [template timed_join_link[link_text] [link thread.thread_management.thread.timed_join [link_text]]]
 [def __timed_join__ [timed_join_link `timed_join()`]]
 [def __detach__ [link thread.thread_management.thread.detach `detach()`]]
 [def __interrupt__ [link thread.thread_management.thread.interrupt `interrupt()`]]
 [def __sleep__ [link thread.thread_management.this_thread.sleep `boost::this_thread::sleep()`]]
+[def __sleep_for [link thread.thread_management.this_thread.sleep_for `sleep_for`]]
+[def __sleep_until [link thread.thread_management.this_thread.sleep_until `sleep_until`]]

 [def __interruption_enabled__ [link thread.thread_management.this_thread.interruption_enabled `boost::this_thread::interruption_enabled()`]]
 [def __interruption_requested__ [link thread.thread_management.this_thread.interruption_requested `boost::this_thread::interruption_requested()`]]
@@ -125,11 +153,21 @@
 [def __cond_wait__ [cond_wait_link `wait()`]]
 [template cond_timed_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable.timed_wait [link_text]]]
 [def __cond_timed_wait__ [cond_timed_wait_link `timed_wait()`]]
+
+[def __condition_variable [link thread.synchronization.condvar_ref.condition_variable `condition_variable`]]
+[def __wait_for [link thread.synchronization.condvar_ref.condition_variable.wait_for `wait_for`]]
+[def __wait_until [link thread.synchronization.condvar_ref.condition_variable.wait_until `wait_until`]]
+
+
 [template cond_any_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable_any.wait [link_text]]]
 [def __cond_any_wait__ [cond_any_wait_link `wait()`]]
 [template cond_any_timed_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable_any.timed_wait [link_text]]]
 [def __cond_any_timed_wait__ [cond_any_timed_wait_link `timed_wait()`]]

+[def __condition_variable_any [link thread.synchronization.condvar_ref.condition_variable_any `condition_variable_any`]]
+[def __cvany_wait_for [link thread.synchronization.condvar_ref.condition_variable_any.wait_for `wait_for`]]
+[def __cvany_wait_until [link thread.synchronization.condvar_ref.condition_variable_any.wait_until `wait_until`]]
+
 [def __blocked__ ['blocked]]

 [include overview.qbk]
@@ -143,6 +181,7 @@
 [include condition_variables.qbk]
 [include once.qbk]
 [include barrier.qbk]
+[include futures.qbk]
 [endsect]

 [include tss.qbk]
@@ -150,3 +189,5 @@
 [include time.qbk]

 [include acknowledgements.qbk]
+
+[include compliance.qbk]
--- a/doc/thread_ref.qbk
+++ b/doc/thread_ref.qbk
@@ -1,6 +1,42 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  (C) Copyright 2011-12 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).
+]
+
 [section:thread_management Thread Management]

-[heading Synopsis]
+[section:synopsis Synopsis]
+
+  namespace boost 
+  {
+    class thread;
+    void swap(thread& lhs,thread& rhs);
+    namespace this_thread 
+    {
+      thread::id get_id() noexcept;
+      template<typename TimeDuration>
+      void sleep(TimeDuration const& rel_time); // DEPRECATED
+      void sleep(system_time const& abs_time)  // DEPRECATED
+      void yield() noexcept;
+      template <class Clock, class Duration>
+      void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 
+      template <class Rep, class Period>
+      void sleep_for(const chrono::duration<Rep, Period>& rel_time);
+
+      void interruption_point();
+      bool interruption_requested();
+      bool interruption_enabled();
+      class disable_interruption;
+      class restore_interruption;
+    }
+  }
+
+[endsect] [/section:synopsis Synopsis]
+
+[section:tutorial Tutorial]

 The __thread__ class is responsible for launching and managing threads. Each __thread__ object represents a single thread of execution,
 or __not_a_thread__, and at most one __thread__ object represents a given thread of execution: objects of type __thread__ are not
@@ -17,14 +53,14 @@ allows the details of thread creation to be wrapped in a function.
        some_thread.join();
    }

-[Note: On compilers that support rvalue references, __thread__ provides a proper move constructor and move-assignment operator, and
+[note On compilers that support rvalue references, __thread__ provides a proper move constructor and move-assignment operator, and
 therefore meets the C++0x ['MoveConstructible] and ['MoveAssignable] concepts. With such compilers, __thread__ can therefore be used
 with containers that support those concepts.

 For other compilers, move support is provided with a move emulation layer, so containers must explicitly detect that move emulation
 layer. See <boost/thread/detail/move.hpp> for details.]

-[heading Launching threads]
+[section:launching Launching threads]

 A new thread is launched by passing an object of a callable type that can be invoked with no parameters to the constructor. The
 object is then copied into internal storage, and invoked on the newly-created thread of execution. If the object must not (or
@@ -61,12 +97,99 @@ to callable functions.

 There is an unspecified limit on the number of additional arguments that can be passed.

-[heading Exceptions in thread functions]
+[endsect]
+
+[section:attributes Thread attributes]
+
+Thread launched in this way are created with implementation defined thread attributes as stack size, scheduling, 
+priority, ... or any platform specific attributes. It is not evident how to provide a portable interface that allows 
+the user to set the platform specific attributes. Boost.Thread stay in the middle road through the class 
+thread::attributes which allows to set at least in a portable way the stack size as follows:
+
+  boost::thread::attributes attrs;
+  attrs.set_size(4096*10);
+  boost::thread deep_thought_2(attrs, find_the_question, 42);
+
+Even for this simple attribute there could be portable issues as some platforms could require that the stack size 
+should have a minimal size and/or be a multiple of a given page size. 
+The library adapts the requested size to the platform constraints so that the user doesn't need to take care of it.
+
+This is the single attribute that is provided in a portable way. In order to set any other thread attribute at 
+construction time the user needs to use non portable code.
+
+On PThread platforms the user will need to get the thread attributes handle and use it for whatever attribute.
+
+Next follows how the user could set the stack size and the scheduling policy on PThread platforms.
+
+    boost::thread::attributes attrs;
+    // set portable attributes
+    // ...
+    attr.set_stack_size(4096*10);
+    #if defined(BOOST_THREAD_PLATFORM_WIN32)
+        // ... window version
+    #elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+        // ... pthread version
+        pthread_attr_setschedpolicy(attr.get_native_handle(), SCHED_RR);
+    #else
+    #error "Boost threads unavailable on this platform"
+    #endif
+    boost::thread th(attrs, find_the_question, 42);
+        
+On Windows platforms it is not so simple as there is no type that compiles the thread attributes. 
+There is a linked to the creation of a thread on Windows that is emulated via the thread::attributes class. This is the LPSECURITY_ATTRIBUTES lpThreadAttributes.
+Boost.Thread provides a non portable set_security function so that the user can provide it before the thread creation as follows
+  
+[/Boost.Thread creates Windows threads that are suspended. Then it calls to the virtual function set_attributes and last it resumes the thread. 
+The user needs to define a class that inherits from the class thread::attributes that defines a virtual function set_attributes to set any specific Windows thread attribute.
+
+
+    class MyWinTthreadAttributes : boost::thread::attributes
+    {
+    public:
+      void set_attributes(boost::thread::native_handle_type h)
+      {
+        // use any specific windows thread setting
+        
+      }
+    };
+    #if defined(BOOST_THREAD_PLATFORM_WIN32)
+    
+      MyWinTthreadAttributes attrs;
+      // set portable attributes
+      // ...
+      attr.set_stack_size(4096*10);
+      boost::thread th(attrs, find_the_question, 42);
+    #else
+    #error "Platform not supported"
+    #endif
+
+]
+
+    #if defined(BOOST_THREAD_PLATFORM_WIN32)
+      boost::thread::attributes attrs;
+      // set portable attributes
+      attr.set_stack_size(4096*10);
+      // set non portable attribute
+      LPSECURITY_ATTRIBUTES sec;
+      // init sec 
+      attr.set_security(sec);
+      boost::thread th(attrs, find_the_question, 42);
+      // Set other thread attributes using the native_handle_type.
+      //...
+    #else
+    #error "Platform not supported"
+    #endif
+
+[endsect]
+
+[section:exceptions Exceptions in thread functions]

 If the function or callable object passed to the __thread__ constructor propagates an exception when invoked that is not of type
 __thread_interrupted__, `std::terminate()` is called. 

-[heading Joining and detaching]
+[endsect]
+
+[section:join Joining and detaching]

 When the __thread__ object that represents a thread of execution is destroyed the thread becomes ['detached]. Once a thread is
 detached, it will continue executing until the invocation of the function or callable object supplied on construction has completed,
@@ -79,7 +202,9 @@ execution represented by the __thread__ object has already completed, or the __t
 returns immediately. __timed_join__ is similar, except that a call to __timed_join__ will also return if the thread being waited for
 does not complete when the specified time has elapsed.

-[heading Interruption]
+[endsect]
+
+[section:interruption Interruption]

 A running thread can be ['interrupted] by invoking the __interrupt__ member function of the corresponding __thread__ object. When the
 interrupted thread next executes one of the specified __interruption_points__ (or if it is currently __blocked__ whilst executing one)
@@ -135,16 +260,25 @@ The following functions are ['interruption points], which will throw __thread_in
 current thread, and interruption is requested for the current thread:

 * [join_link `boost::thread::join()`]
-* [timed_join_link `boost::thread::timed_join()`]
+* [timed_join_link `boost::thread::timed_join()` DEPRECATED V2]
+* `boost::__thread::__try_join_for()`,
+* `boost::__thread::__try_join_until()`,
 * [cond_wait_link `boost::condition_variable::wait()`]
-* [cond_timed_wait_link `boost::condition_variable::timed_wait()`]
+* [cond_timed_wait_link `boost::condition_variable::timed_wait()` DEPRECATED V2]
+* `boost::__condition_variable::__wait_for()`
+* `boost::__condition_variable::__wait_until()`
 * [cond_any_wait_link `boost::condition_variable_any::wait()`]
-* [cond_any_timed_wait_link `boost::condition_variable_any::timed_wait()`]
-* [link thread.thread_management.thread.sleep `boost::thread::sleep()`]
-* __sleep__
+* [cond_any_timed_wait_link `boost::condition_variable_any::timed_wait()` DEPRECATED V2]
+* `boost::__condition_variable_any::__cvany_wait_for()`
+* `boost::__condition_variable_any::__cvany_wait_until()`
+* [link thread.thread_management.thread.sleep `boost::thread::sleep()` DEPRECATED V2]
+* `boost::this_thread::__sleep_for()`
+* `boost::this_thread::__sleep_until()`
 * __interruption_point__

-[heading Thread IDs]
+[endsect]
+
+[section:id Thread IDs]

 Objects of class __thread_id__ can be used to identify threads. Each running thread of execution has a unique ID obtainable
 from the corresponding __thread__ by calling the `get_id()` member function, or by calling `boost::this_thread::get_id()` from
@@ -156,41 +290,105 @@ Each instance of __thread_id__ either refers to some thread, or __not_a_thread__
 compare equal to each other, but not equal to any instances that refer to an actual thread of execution. The comparison operators on
 __thread_id__ yield a total order for every non-equal thread ID.

+[endsect]
+
+[section:native_in Using native interfaces with Boost.Thread resources] 
+
+
+__thread__ class has members `native_handle_type` and `native_handle` providing access to the underlying native handle.  
+	 
+This native handle can be used to change for example the scheduling. 
+
+In general, it is not safe to use this handle with operations that can conflict with the ones provided by Boost.Thread. An example of bad usage could be detaching a thread directly as it will not change the internals of the __thread__ instance, so for example the joinable function will continue to return true, while the native thread is no more joinable. 
+
+  thread t(fct); 
+  thread::native_handle_type hnd=t.native_handle(); 
+  pthread_detach(hnd); 
+  assert(t.joinable()); 
+
+[endsect]
+
+[section:native_from Using Boost.Thread interfaces in a native thread] 
+ 
+
+Any thread of execution created using the native interface is called a native thread in this documentation. 
+
+The first example of a native thread of execution is the main thread.  
+
+The user can access to some synchronization functions related to the native current thread using the `boost::this_thread` `yield`, `sleep`, __sleep_for, __sleep_until, functions. 
+
+
+  int main() { 
+    // ... 
+    boost::this_thread::sleep_for(boost::chrono::milliseconds(10)); 
+    // ... 
+  } 
+
+
+Of course all the synchronization facilities provided by Boost.Thread are also available on native threads. 
+
+The `boost::this_thread` interrupt related functions behave in a degraded mode when called from a thread created using the native interface, i.e. `boost::this_thread::interruption_enabled()` returns false. As consequence the use of `boost::this_thread::disable_interruption` and `boost::this_thread::restore_interruption` will do nothing and calls to `boost::this_thread::interrupt_point()` will be just ignored.  
+
+As the single way to interrupt a thread is through a __thread__ instance, `interruption_request()` wiil returns false for the native threads. 
+
+[heading `pthread_exit` POSIX limitation]
+
+`pthread_exit` in glibc/NPTL causes a "forced unwind" that is almost like a C++ exception, but not quite. On Mac OS X, for example, `pthread_exit` unwinds without calling C++ destructors.
+
+This behavior is incompatible with the current Boost.Thread design, so the use of this function in a POSIX thread result in undefined behavior of any Boost.Thread function.
+
+[endsect]
+
+[endsect] [/section:tutorial Tutorial]
+
 [section:thread Class `thread`]

+    #include <boost/thread/thread.hpp>
+
    class thread
    {
    public:
-        thread();
+        thread() noexcept;
+        thread(const thread&) = delete;
+        thread& operator=(const thread&) = delete;
+
+        thread(thread&&) noexcept;
+        thread& operator=(thread&&) noexcept;
        ~thread();

        template <class F>
        explicit thread(F f);

+        template <class F,class A1,class A2,...>
+        thread(F f,A1 a1,A2 a2,...);
+
        template <class F>
-        thread(detail::thread_move_t<F> f);
+        thread(F &&f);
+
+        template <class F, class ...Args> explicit thread(F&& f, Args&&... args);

        // move support
-        thread(detail::thread_move_t<thread> x);
-        thread& operator=(detail::thread_move_t<thread> x);
-        operator detail::thread_move_t<thread>();
-        detail::thread_move_t<thread> move();
+        thread(thread && x);
+        thread& operator=(thread && x);

-        void swap(thread& x);
+        void swap(thread& x) noexcept;

        class id;
-        id get_id() const;
+        id get_id() const noexcept;

-        bool joinable() const;
+        bool joinable() const noexcept;
        void join();
-        bool timed_join(const system_time& wait_until);
-
+        bool timed_join(const system_time& wait_until); // DEPRECATED V2
        template<typename TimeDuration>
-        bool timed_join(TimeDuration const& rel_time);
+        bool timed_join(TimeDuration const& rel_time);  // DEPRECATED V2
+        template <class Rep, class Period>
+        bool try_join_for(const chrono::duration<Rep, Period>& rel_time);
+        template <class Clock, class Duration>
+        bool try_join_until(const chrono::time_point<Clock, Duration>& t);

        void detach();

-        static unsigned hardware_concurrency();
+        static unsigned hardware_concurrency() noexcept;

        typedef platform-specific-type native_handle_type;
        native_handle_type native_handle();
@@ -199,18 +397,19 @@ __thread_id__ yield a total order for every non-equal thread ID.
        bool interruption_requested() const;

        // backwards compatibility
-        bool operator==(const thread& other) const;
-        bool operator!=(const thread& other) const;
+        bool operator==(const thread& other) const; // DEPRECATED V2
+        bool operator!=(const thread& other) const; // DEPRECATED V2
+
+        static void yield(); // DEPRECATED V2
+        static void sleep(const system_time& xt); // DEPRECATED V2

-        static void yield();
-        static void sleep(const system_time& xt);
    };

-    void swap(thread& lhs,thread& rhs);
+    void swap(thread& lhs,thread& rhs) noexcep;

 [section:default_constructor Default Constructor]

-    thread();
+    thread() noexcep;

 [variablelist

@@ -222,6 +421,40 @@ __thread_id__ yield a total order for every non-equal thread ID.

 [endsect]

+[section:move_constructor Move Constructor]
+
+    thread(thread&& other) noexcept;
+
+[variablelist
+
+[[Effects:] [Transfers ownership of the thread managed by `other` (if any) to the newly constructed __thread__ instance.]]
+
+[[Postconditions:] [`other->get_id()==thread::id()`]]
+
+[[Throws:] [Nothing]]
+
+]
+
+[endsect]
+
+[section:move_assignment Move assignment operator]
+
+    thread& operator=(thread&& other) noexcept;
+
+[variablelist
+
+[[Effects:] [Transfers ownership of the thread managed by `other` (if
+any) to `*this`. If there was a thread previously associated with
+`*this` then that thread is detached.]]
+
+[[Postconditions:] [`other->get_id()==thread::id()`]]
+
+[[Throws:] [Nothing]]
+
+]
+
+[endsect]
+
 [section:callable_constructor Thread Constructor]

    template<typename Callable>
@@ -237,8 +470,44 @@ not of type __thread_interrupted__, then `std::terminate()` will be called.]]

 [[Postconditions:] [`*this` refers to the newly created thread of execution.]]

+[[Throws:] [__thread_resource_error__ if an error occurs. ]]
+
+[[Error Conditions:] [
+
+[*resource_unavailable_try_again] : the system lacked the necessary resources to create an- other thread, or the system-imposed limit on the number of threads in a process would be exceeded. 
+
+]]
+
+]
+
+[endsect]
+
+[section:multiple_argument_constructor Thread Constructor with arguments]
+
+    template <class F,class A1,class A2,...>
+    thread(F f,A1 a1,A2 a2,...);
+
+[variablelist
+
+[[Preconditions:] [`F` and each `A`n must by copyable or movable.]]
+
+[[Effects:] [As if [link
+thread.thread_management.thread.callable_constructor
+`thread(boost::bind(f,a1,a2,...))`. Consequently, `f` and each `a`n
+are copied into internal storage for access by the new thread.]]]
+
+[[Postconditions:] [`*this` refers to the newly created thread of execution.]]
+
 [[Throws:] [__thread_resource_error__ if an error occurs.]]

+[[Error Conditions:] [
+
+[*resource_unavailable_try_again] : the system lacked the necessary resources to create an- other thread, or the system-imposed limit on the number of threads in a process would be exceeded. 
+
+]]
+
+[[Note:] [Currently up to nine additional arguments `a1` to `a9` can be specified in addition to the function `f`.]]
+
 ]

 [endsect]
@@ -259,7 +528,7 @@ not of type __thread_interrupted__, then `std::terminate()` will be called.]]

 [section:joinable Member function `joinable()`]

-    bool joinable() const;
+    bool joinable() const noexcept;

 [variablelist

@@ -284,7 +553,19 @@ not of type __thread_interrupted__, then `std::terminate()` will be called.]]

 [[Postconditions:] [If `*this` refers to a thread of execution on entry, that thread of execution has completed. `*this` no longer refers to any thread of execution.]]

-[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted.]]
+[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted or `system_error`]]
+
+[[Error Conditions:] [
+
+[*resource_deadlock_would_occur]: if deadlock is detected or this->get_id() == std::this_thread::get_id().
+
+[/
+[*no_such_process]: if the thread is not valid.
+
+[*invalid_argument]: if the thread is not joinable.
+] 
+
+]]

 [[Notes:] [`join()` is one of the predefined __interruption_points__.]]

@@ -292,7 +573,7 @@ not of type __thread_interrupted__, then `std::terminate()` will be called.]]

 [endsect]

-[section:timed_join Member function `timed_join()`]
+[section:timed_join Member function `timed_join()` DEPRECATED V2]

    bool timed_join(const system_time& wait_until);

@@ -313,7 +594,19 @@ times out, `false` otherwise.]]
 has completed, and `*this` no longer refers to any thread of execution. If this call to `timed_join` returns `false`, `*this` is
 unchanged.]]

-[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted.]]
+[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted or `system_error`]]
+
+[[Error Conditions:] [
+
+[*resource_deadlock_would_occur]: if deadlock is detected or this->get_id() == std::this_thread::get_id().
+
+[/
+[*no_such_process]: if the thread is not valid.
+
+[*invalid_argument]: if the thread is not joinable.
+] 
+
+]]

 [[Notes:] [`timed_join()` is one of the predefined __interruption_points__.]]

@@ -321,6 +614,86 @@ unchanged.]]

 [endsect]

+[section:try_join_for Member function `try_join_for()`]
+
+        template <class Rep, class Period>
+        bool try_join_for(const chrono::duration<Rep, Period>& rel_time);
+
+[variablelist
+
+[[Preconditions:] [`this->get_id()!=boost::this_thread::get_id()`]]
+
+[[Effects:] [If `*this` refers to a thread of execution, waits for that thread of execution to complete, 
+the specified duration `rel_time` has elapsed. If `*this` doesn't refer to a thread of execution, returns immediately.]]
+
+[[Returns:] [`true` if `*this` refers to a thread of execution on entry, and that thread of execution has completed before the call
+times out, `false` otherwise.]]
+
+[[Postconditions:] [If `*this` refers to a thread of execution on entry, and `try_join_for` returns `true`, that thread of execution
+has completed, and `*this` no longer refers to any thread of execution. If this call to `try_join_for` returns `false`, `*this` is
+unchanged.]]
+
+[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted or `system_error`]]
+
+[[Error Conditions:] [
+
+[*resource_deadlock_would_occur]: if deadlock is detected or this->get_id() == std::this_thread::get_id().
+
+[/
+[*no_such_process]: if the thread is not valid.
+
+[*invalid_argument]: if the thread is not joinable.
+] 
+
+]]
+
+[[Notes:] [`try_join_for()` is one of the predefined __interruption_points__.]]
+
+]
+
+[endsect]
+
+[section:try_join_until Member function `try_join_until()`]
+
+        template <class Clock, class Duration>
+        bool try_join_until(const chrono::time_point<Clock, Duration>& abs_time);
+
+[variablelist
+
+[[Preconditions:] [`this->get_id()!=boost::this_thread::get_id()`]]
+
+[[Effects:] [If `*this` refers to a thread of execution, waits for that thread of execution to complete, the time `abs_time` has
+been reach. If `*this` doesn't refer to a thread of execution, returns immediately.]]
+
+[[Returns:] [`true` if `*this` refers to a thread of execution on entry, and that thread of execution has completed before the call
+times out, `false` otherwise.]]
+
+[[Postconditions:] [If `*this` refers to a thread of execution on entry, and `try_join_until` returns `true`, that thread of execution
+has completed, and `*this` no longer refers to any thread of execution. If this call to `try_join_until` returns `false`, `*this` is
+unchanged.]]
+
+[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted or `system_error`]]
+
+[[Error Conditions:] [
+
+[*resource_deadlock_would_occur]: if deadlock is detected or this->get_id() == std::this_thread::get_id().
+
+[/
+[*no_such_process]: if the thread is not valid.
+
+[*invalid_argument]: if the thread is not joinable.
+] 
+
+]]
+
+[[Notes:] [`try_join_until()` is one of the predefined __interruption_points__.]]
+
+]
+
+[endsect]
+
+
+
 [section:detach Member function `detach()`]

    void detach();
@@ -340,7 +713,7 @@ unchanged.]]

 [section:get_id Member function `get_id()`]

-    thread::id get_id() const;
+    thread::id get_id() const noexcept;

 [variablelist

@@ -372,7 +745,7 @@ predefined __interruption_points__ with interruption enabled .]]

 [section:hardware_concurrency Static member function `hardware_concurrency()`]

-    unsigned hardware_concurrency();
+    unsigned hardware_concurrency() noexecpt;

 [variablelist

@@ -425,7 +798,7 @@ implementation. If no such instance exists, `native_handle()` and `native_handle

 [endsect]

-[section:sleep Static member function `sleep()`]
+[section:sleep Static member function `sleep()` DEPRECATED V2]

    void sleep(system_time const& abs_time);

@@ -441,7 +814,7 @@ implementation. If no such instance exists, `native_handle()` and `native_handle

 [endsect]

-[section:yield Static member function `yield()`]
+[section:yield Static member function `yield()` DEPRECATED V2]

    void yield();

@@ -455,7 +828,7 @@ implementation. If no such instance exists, `native_handle()` and `native_handle

 [section:swap Member function `swap()`]

-    void swap(thread& other);
+    void swap(thread& other) noexcept;

 [variablelist

@@ -473,7 +846,9 @@ value as `this->get_id()` prior to the call.]]

 [section:non_member_swap Non-member function `swap()`]

-    void swap(thread& lhs,thread& rhs);
+    #include <boost/thread/thread.hpp>
+
+    void swap(thread& lhs,thread& rhs) noexcept;

 [variablelist

@@ -483,20 +858,43 @@ value as `this->get_id()` prior to the call.]]

 [endsect]

+[/
+[section:non_member_move Non-member function `move()`]
+
+    #include <boost/thread/thread.hpp>
+
+    detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
+
+[variablelist
+
+[[Returns:] [`t`.]]
+
+]
+
+Enables moving thread objects. e.g.
+
+    extern void some_func();
+    boost::thread t(some_func);
+    boost::thread t2(boost::move(t)); // transfer thread from t to t2
+
+[endsect]
+]

 [section:id Class `boost::thread::id`]

+    #include <boost/thread/thread.hpp>
+
    class thread::id
    {
    public:
-        id();
+        id() noexcept;

-        bool operator==(const id& y) const;
-        bool operator!=(const id& y) const;
-        bool operator<(const id& y) const;
-        bool operator>(const id& y) const;
-        bool operator<=(const id& y) const;
-        bool operator>=(const id& y) const;
+        bool operator==(const id& y) const noexcept;
+        bool operator!=(const id& y) const noexcept;
+        bool operator<(const id& y) const noexcept;
+        bool operator>(const id& y) const noexcept;
+        bool operator<=(const id& y) const noexcept;
+        bool operator>=(const id& y) const noexcept;

        template<class charT, class traits>
        friend std::basic_ostream<charT, traits>& 
@@ -505,7 +903,7 @@ value as `this->get_id()` prior to the call.]]

 [section:constructor Default constructor]

-    id();
+    id() noexcept;

 [variablelist

@@ -519,7 +917,7 @@ value as `this->get_id()` prior to the call.]]

 [section:is_equal `operator==`]

-    bool operator==(const id& y) const;
+    bool operator==(const id& y) const noexcept;

 [variablelist

@@ -534,7 +932,7 @@ otherwise.]]

 [section:not_equal `operator!=`]

-    bool operator!=(const id& y) const;
+    bool operator!=(const id& y) const noexcept;

 [variablelist

@@ -549,7 +947,7 @@ the other represent __not_a_thread__, `false` otherwise.]]

 [section:less_than `operator<`]

-    bool operator<(const id& y) const;
+    bool operator<(const id& y) const noexcept;

 [variablelist

@@ -568,7 +966,7 @@ execution.]]

 [section:greater_than `operator>`]

-    bool operator>(const id& y) const;
+    bool operator>(const id& y) const noexcept;

 [variablelist

@@ -580,9 +978,9 @@ execution.]]

 [endsect]

-[section:less_than_or_equal `operator>=`]
+[section:less_than_or_equal `operator<=`]

-    bool operator<=(const id& y) const;
+    bool operator<=(const id& y) const noexcept;

 [variablelist

@@ -596,7 +994,7 @@ execution.]]

 [section:greater_than_or_equal `operator>=`]

-    bool operator>=(const id& y) const;
+    bool operator>=(const id& y) const noexcept;

 [variablelist

@@ -632,11 +1030,34 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [section:this_thread Namespace `this_thread`]

+
+  namespace boost {
+    namespace this_thread {
+      thread::id get_id() noexcept;
+      template<typename TimeDuration>
+      void sleep(TimeDuration const& rel_time); // DEPRECATED V2
+      void sleep(system_time const& abs_time)  // DEPRECATED V2
+      void yield() noexcept;
+      template <class Clock, class Duration>
+      void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 
+      template <class Rep, class Period>
+      void sleep_for(const chrono::duration<Rep, Period>& rel_time);
+
+      void interruption_point();
+      bool interruption_requested();
+      bool interruption_enabled();
+      class disable_interruption;
+      class restore_interruption;
+    }
+  }
+
 [section:get_id Non-member function `get_id()`]

+    #include <boost/thread/thread.hpp>
+
    namespace this_thread
    {
-        thread::id get_id();
+        thread::id get_id() noexcept;
    }

 [variablelist
@@ -651,6 +1072,8 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [section:interruption_point Non-member function `interruption_point()`]

+    #include <boost/thread/thread.hpp>
+
    namespace this_thread
    {
        void interruption_point();
@@ -668,6 +1091,8 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [section:interruption_requested Non-member function `interruption_requested()`]

+    #include <boost/thread/thread.hpp>
+
    namespace this_thread
    {
        bool interruption_requested();
@@ -685,6 +1110,8 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [section:interruption_enabled Non-member function `interruption_enabled()`]

+    #include <boost/thread/thread.hpp>
+
    namespace this_thread
    {
        bool interruption_enabled();
@@ -700,17 +1127,22 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [endsect]

-[section:sleep Non-member function `sleep()`]
+[section:sleep Non-member function `sleep()` DEPRECATED V2]
+
+    #include <boost/thread/thread.hpp>

    namespace this_thread
    {
        template<typename TimeDuration>
        void sleep(TimeDuration const& rel_time);
+        void sleep(system_time const& abs_time)
    }

 [variablelist

-[[Effects:] [Suspends the current thread until the specified time has elapsed.]]
+[[Effects:] [Suspends the current thread until the time period
+specified by `rel_time` has elapsed or the time point specified by
+`abs_time` has been reached.]]

 [[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted.]]

@@ -720,8 +1152,59 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [endsect]

+[section:sleep_until Non-member function `sleep_until()`]
+
+    #include <boost/thread/thread.hpp>
+
+    namespace this_thread
+    {
+      template <class Clock, class Duration>
+      void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 
+    }
+
+[variablelist
+
+[[Effects:] [Suspends the current thread until the time period
+specified by `rel_time` has elapsed or the time point specified by
+`abs_time` has been reached.]]
+
+[[Throws:] [Nothing if Clock satisfies the TrivialClock requirements and operations of Duration
+do not throw exceptions. __thread_interrupted__ if the current thread of execution is interrupted. ]]
+
+[[Notes:] [`sleep_until()` is one of the predefined __interruption_points__.]]
+
+]
+
+[endsect]
+
+[section:sleep_for Non-member function `sleep_for()`]
+
+    #include <boost/thread/thread.hpp>
+
+    namespace this_thread
+    {
+      template <class Rep, class Period>
+      void sleep_for(const chrono::duration<Rep, Period>& rel_time);
+    }
+
+[variablelist
+
+[[Effects:] [Suspends the current thread until the time point specified by
+`abs_time` has been reached.]]
+
+[[Throws:] [Nothing if operations of chrono::duration<Rep, Period> do not throw exceptions. __thread_interrupted__ if the current thread of execution is interrupted.]]
+
+[[Notes:] [`sleep_for()` is one of the predefined __interruption_points__.]]
+
+]
+
+[endsect]
+
+
 [section:yield Non-member function `yield()`]

+    #include <boost/thread/thread.hpp>
+
    namespace this_thread
    {
        void yield();
@@ -739,6 +1222,8 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [section:disable_interruption Class `disable_interruption`]

+    #include <boost/thread/thread.hpp>
+
    namespace this_thread
    {
        class disable_interruption
@@ -790,6 +1275,8 @@ interruption state on destruction. Instances of `disable_interruption` cannot be

 [section:restore_interruption Class `restore_interruption`]

+    #include <boost/thread/thread.hpp>
+
    namespace this_thread
    {
        class restore_interruption
@@ -844,18 +1331,29 @@ is destroyed, interruption is again disabled. Instances of `restore_interruption

 [section:atthreadexit Non-member function template `at_thread_exit()`]

+    #include <boost/thread/thread.hpp>
+
    template<typename Callable>
    void at_thread_exit(Callable func);

 [variablelist

-[[Effects:] [A copy of `func` is taken and stored to in thread-specific storage. This copy is invoked when the current thread exits.]]
+[[Effects:] [A copy of `func` is placed in
+thread-specific storage. This copy is invoked when the current thread
+exits (even if the thread has been interrupted).]]

 [[Postconditions:] [A copy of `func` has been saved for invocation on thread exit.]]

 [[Throws:] [`std::bad_alloc` if memory cannot be allocated for the copy of the function, __thread_resource_error__ if any other
 error occurs within the thread library. Any exception thrown whilst copying `func` into internal storage.]]

+[[Note:] [This function is *not* called if the thread was terminated
+forcefully using platform-specific APIs, or if the thread is
+terminated due to a call to `exit()`, `abort()` or
+`std::terminate()`. In particular, returning from `main()` is
+equivalent to call to `exit()`, so will not call any functions
+registered with `at_thread_exit()`]]
+
 ]

 [endsect]
@@ -864,6 +1362,8 @@ error occurs within the thread library. Any exception thrown whilst copying `fun

 [section:threadgroup Class `thread_group`]

+    #include <boost/thread/thread.hpp>
+
    class thread_group:
        private noncopyable
    {
@@ -871,7 +1371,8 @@ error occurs within the thread library. Any exception thrown whilst copying `fun
        thread_group();
        ~thread_group();

-        thread* create_thread(const function0<void>& threadfunc);
+        template<typename F>
+        thread* create_thread(F threadfunc);
        void add_thread(thread* thrd);
        void remove_thread(thread* thrd);
        void join_all();
@@ -908,7 +1409,8 @@ error occurs within the thread library. Any exception thrown whilst copying `fun

 [section:create_thread Member function `create_thread()`]

-    thread* create_thread(const function0<void>& threadfunc);
+    template<typename F>
+    thread* create_thread(F threadfunc);

 [variablelist

--- a/doc/time.qbk
+++ b/doc/time.qbk
@@ -1,3 +1,10 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
 [section:time Date and Time Requirements]

 As of Boost 1.35.0, the __boost_thread__ library uses the [link date_time Boost.Date_Time] library for all operations that require a
@@ -40,6 +47,8 @@ date_time.posix_time.time_duration Boost.Date_Time Time Duration requirements] c

 [section:system_time Typedef `system_time`]

+    #include <boost/thread/thread_time.hpp>
+
    typedef boost::posix_time::ptime system_time;

 See the documentation for [link date_time.posix_time.ptime_class `boost::posix_time::ptime`] in the Boost.Date_Time library.
@@ -48,6 +57,8 @@ See the documentation for [link date_time.posix_time.ptime_class `boost::posix_t

 [section:get_system_time Non-member function `get_system_time()`]

+    #include <boost/thread/thread_time.hpp>
+
    system_time get_system_time();

 [variablelist
--- a/doc/tss.qbk
+++ b/doc/tss.qbk
@@ -1,3 +1,10 @@
+[/
+  (C) Copyright 2007-8 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
 [section Thread Local Storage]

 [heading Synopsis]
@@ -34,9 +41,16 @@ order. If a cleanup routine sets the value of associated with an instance of `bo
 cleaned up, that value is added to the cleanup list. Cleanup finishes when there are no outstanding instances of
 `boost::thread_specific_ptr` with values.

+Note: on some platforms, cleanup of thread-specific data is not
+performed for threads created with the platform's native API. On those
+platforms such cleanup is only done for threads that are started with
+`boost::thread` unless `boost::on_thread_exit()` is called manually
+from that thread.

 [section:thread_specific_ptr Class `thread_specific_ptr`]

+    #include <boost/thread/tss.hpp>
+
    template <typename T>
    class thread_specific_ptr
    {
--- a/example/condition.cpp
+++ b/example/condition.cpp
@@ -50,8 +50,9 @@ boost::mutex io_mutex;

 void sender() {
    int n = 0;
-    while (n < 100) {
+    while (n < 1000000) {
        buf.send(n);
+        if(!(n%10000))
        {
            boost::mutex::scoped_lock io_lock(io_mutex);
            std::cout << "sent: " << n << std::endl;
@@ -65,18 +66,24 @@ void receiver() {
    int n;
    do {
        n = buf.receive();
+        if(!(n%10000))
        {
            boost::mutex::scoped_lock io_lock(io_mutex);
            std::cout << "received: " << n << std::endl;
        }
    } while (n != -1); // -1 indicates end of buffer
+    buf.send(-1);
 }

 int main(int, char*[])
 {
    boost::thread thrd1(&sender);
    boost::thread thrd2(&receiver);
+    boost::thread thrd3(&receiver);
+    boost::thread thrd4(&receiver);
    thrd1.join();
    thrd2.join();
+    thrd3.join();
+    thrd4.join();
    return 0;
 }
--- a/example/shared_monitor.cpp
+++ b/example/shared_monitor.cpp
@@ -0,0 +1,136 @@
+// Copyright (C) 2012 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 <iostream>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/chrono/chrono_io.hpp>
+
+#include <cassert>
+#include <vector>
+
+#define EXCLUSIVE 1
+#define SHARED 2
+
+#define MODE SHARED
+
+class A
+{
+#if MODE == EXCLUSIVE
+    typedef boost::mutex mutex_type;
+#elif MODE == SHARED
+    typedef boost::shared_mutex mutex_type;
+#else
+#error MODE not set
+#endif
+    typedef std::vector<double> C;
+    mutable mutex_type mut_;
+    C data_;
+public:
+    A() : data_(10000000) {}
+    A(const A& a);
+    A& operator=(const A& a);
+
+    void compute(const A& x, const A& y);
+};
+
+A::A(const A& a)
+{
+#if MODE == EXCLUSIVE
+    boost::unique_lock<mutex_type> lk(a.mut_);
+#elif MODE == SHARED
+    boost::shared_lock<mutex_type> lk(a.mut_);
+#else
+#error MODE not set
+#endif
+    data_ = a.data_;
+}
+
+A&
+A::operator=(const A& a)
+{
+    if (this != &a)
+    {
+        boost::unique_lock<mutex_type> lk1(mut_, boost::defer_lock);
+#if MODE == EXCLUSIVE
+        boost::unique_lock<mutex_type> lk2(a.mut_, boost::defer_lock);
+#elif MODE == SHARED
+        boost::shared_lock<mutex_type> lk2(a.mut_, boost::defer_lock);
+#else
+#error MODE not set
+#endif
+        boost::lock(lk1, lk2);
+        data_ = a.data_;
+    }
+    return *this;
+}
+
+void
+A::compute(const A& x, const A& y)
+{
+    boost::unique_lock<mutex_type> lk1(mut_, boost::defer_lock);
+#if MODE == EXCLUSIVE
+    boost::unique_lock<mutex_type> lk2(x.mut_, boost::defer_lock);
+    boost::unique_lock<mutex_type> lk3(y.mut_, boost::defer_lock);
+#elif MODE == SHARED
+    boost::shared_lock<mutex_type> lk2(x.mut_, boost::defer_lock);
+    boost::shared_lock<mutex_type> lk3(y.mut_, boost::defer_lock);
+#else
+#error MODE not set
+#endif
+    boost::lock(lk1, lk2, lk3);
+    assert(data_.size() == x.data_.size());
+    assert(data_.size() == y.data_.size());
+    for (unsigned i = 0; i < data_.size(); ++i)
+        data_[i] = (x.data_[i] + y.data_[i]) / 2;
+}
+
+A a1;
+A a2;
+
+void test_s()
+{
+    A la3 = a1;
+    for (int i = 0; i < 150; ++i)
+    {
+        la3.compute(a1, a2);
+    }
+}
+
+void test_w()
+{
+    A la3 = a1;
+    for (int i = 0; i < 10; ++i)
+    {
+        la3.compute(a1, a2);
+        a1 = la3;
+        a2 = la3;
+//        boost::this_thread::sleep_for(boost::chrono::seconds(1));
+    }
+}
+
+int main()
+{
+    typedef boost::chrono::high_resolution_clock Clock;
+    typedef boost::chrono::duration<double> sec;
+    Clock::time_point t0 = Clock::now();
+    std::vector<boost::thread*> v;
+    boost::thread thw(test_w);
+    v.push_back(&thw);
+    boost::thread thr0(test_w);
+    v.push_back(&thr0);
+    boost::thread thr1(test_w);
+    v.push_back(&thr1);
+    boost::thread thr2(test_w);
+    v.push_back(&thr2);
+    boost::thread thr3(test_w);
+    v.push_back(&thr3);
+    for (int i = 0; i < v.size(); ++i)
+        v[i]->join();
+    Clock::time_point t1 = Clock::now();
+    std::cout << sec(t1-t0) << '\n';
+    return 0;
+}
--- a/example/shared_mutex.cpp
+++ b/example/shared_mutex.cpp
@@ -0,0 +1,722 @@
+// Copyright (C) 2012 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)
+
+#define BOOST_THREAD_SHARED_MUTEX_PROVIDES_UPWARDS_CONVERSION
+#define BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
+
+#include <iostream>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/chrono/chrono_io.hpp>
+
+#include <cassert>
+#include <vector>
+
+enum {reading, writing};
+int state = reading;
+
+#if 1
+
+boost::mutex&
+cout_mut()
+{
+    static boost::mutex m;
+    return m;
+}
+
+void
+print(const char* tag, unsigned count, char ch)
+{
+    boost::lock_guard<boost::mutex> _(cout_mut());
+    std::cout << tag << count << ch;
+}
+
+#elif 0
+
+boost::recursive_mutex&
+cout_mut()
+{
+    static boost::recursive_mutex m;
+    return m;
+}
+
+void print() {}
+
+template <class A0, class ...Args>
+void
+print(const A0& a0, const Args& ...args)
+{
+    boost::lock_guard<boost::recursive_mutex> _(cout_mut());
+    std::cout << a0;
+    print(args...);
+}
+
+#else
+
+template <class A0, class A1, class A2>
+void
+print(const A0&, const A1& a1, const A2&)
+{
+    assert(a1 > 10000);
+}
+
+#endif
+
+namespace S
+{
+
+boost::shared_mutex mut;
+
+void reader()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        mut.lock_shared();
+        assert(state == reading);
+        ++count;
+        mut.unlock_shared();
+    }
+    print("reader = ", count, '\n');
+}
+
+void writer()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        mut.lock();
+        state = writing;
+        assert(state == writing);
+        state = reading;
+        ++count;
+        mut.unlock();
+    }
+    print("writer = ", count, '\n');
+}
+
+void try_reader()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_shared())
+        {
+            assert(state == reading);
+            ++count;
+            mut.unlock_shared();
+        }
+    }
+    print("try_reader = ", count, '\n');
+}
+
+void try_writer()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock())
+        {
+            state = writing;
+            assert(state == writing);
+            state = reading;
+            ++count;
+            mut.unlock();
+        }
+    }
+    print("try_writer = ", count, '\n');
+}
+
+void try_for_reader()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_shared_for(boost::chrono::microseconds(5)))
+        {
+            assert(state == reading);
+            ++count;
+            mut.unlock_shared();
+        }
+    }
+    print("try_for_reader = ", count, '\n');
+}
+
+void try_for_writer()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_for(boost::chrono::microseconds(5)))
+        {
+            state = writing;
+            assert(state == writing);
+            state = reading;
+            ++count;
+            mut.unlock();
+        }
+    }
+    print("try_for_writer = ", count, '\n');
+}
+
+void
+test_shared_mutex()
+{
+    {
+        boost::thread t1(reader);
+        boost::thread t2(writer);
+        boost::thread t3(reader);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+    {
+        boost::thread t1(try_reader);
+        boost::thread t2(try_writer);
+        boost::thread t3(try_reader);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+    {
+        boost::thread t1(try_for_reader);
+        boost::thread t2(try_for_writer);
+        boost::thread t3(try_for_reader);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+}
+
+}
+
+namespace U
+{
+
+boost::upgrade_mutex mut;
+
+void reader()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        mut.lock_shared();
+        assert(state == reading);
+        ++count;
+        mut.unlock_shared();
+    }
+    print("reader = ", count, '\n');
+}
+
+void writer()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        mut.lock();
+        state = writing;
+        assert(state == writing);
+        state = reading;
+        ++count;
+        mut.unlock();
+    }
+    print("writer = ", count, '\n');
+}
+
+void try_reader()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_shared())
+        {
+            assert(state == reading);
+            ++count;
+            mut.unlock_shared();
+        }
+    }
+    print("try_reader = ", count, '\n');
+}
+
+void try_writer()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock())
+        {
+            state = writing;
+            assert(state == writing);
+            state = reading;
+            ++count;
+            mut.unlock();
+        }
+    }
+    print("try_writer = ", count, '\n');
+}
+
+void try_for_reader()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_shared_for(boost::chrono::microseconds(5)))
+        {
+            assert(state == reading);
+            ++count;
+            mut.unlock_shared();
+        }
+    }
+    print("try_for_reader = ", count, '\n');
+}
+
+void try_for_writer()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_for(boost::chrono::microseconds(5)))
+        {
+            state = writing;
+            assert(state == writing);
+            state = reading;
+            ++count;
+            mut.unlock();
+        }
+    }
+    print("try_for_writer = ", count, '\n');
+}
+
+void upgradable()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        mut.lock_upgrade();
+        assert(state == reading);
+        ++count;
+        mut.unlock_upgrade();
+    }
+    print("upgradable = ", count, '\n');
+}
+
+void try_upgradable()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_upgrade())
+        {
+            assert(state == reading);
+            ++count;
+            mut.unlock_upgrade();
+        }
+    }
+    print("try_upgradable = ", count, '\n');
+}
+
+void try_for_upgradable()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_upgrade_for(boost::chrono::microseconds(5)))
+        {
+            assert(state == reading);
+            ++count;
+            mut.unlock_upgrade();
+        }
+    }
+    print("try_for_upgradable = ", count, '\n');
+}
+
+void clockwise()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        mut.lock_shared();
+        assert(state == reading);
+        if (mut.try_unlock_shared_and_lock())
+        {
+            state = writing;
+        }
+        else if (mut.try_unlock_shared_and_lock_upgrade())
+        {
+            assert(state == reading);
+            mut.unlock_upgrade_and_lock();
+            state = writing;
+        }
+        else
+        {
+            mut.unlock_shared();
+            continue;
+        }
+        assert(state == writing);
+        state = reading;
+        mut.unlock_and_lock_upgrade();
+        assert(state == reading);
+        mut.unlock_upgrade_and_lock_shared();
+        assert(state == reading);
+        mut.unlock_shared();
+        ++count;
+    }
+    print("clockwise = ", count, '\n');
+}
+
+void counter_clockwise()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        mut.lock_upgrade();
+        assert(state == reading);
+        mut.unlock_upgrade_and_lock();
+        assert(state == reading);
+        state = writing;
+        assert(state == writing);
+        state = reading;
+        mut.unlock_and_lock_shared();
+        assert(state == reading);
+        mut.unlock_shared();
+        ++count;
+    }
+    print("counter_clockwise = ", count, '\n');
+}
+
+void try_clockwise()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_shared())
+        {
+            assert(state == reading);
+            if (mut.try_unlock_shared_and_lock())
+            {
+                state = writing;
+            }
+            else if (mut.try_unlock_shared_and_lock_upgrade())
+            {
+                assert(state == reading);
+                mut.unlock_upgrade_and_lock();
+                state = writing;
+            }
+            else
+            {
+                mut.unlock_shared();
+                continue;
+            }
+            assert(state == writing);
+            state = reading;
+            mut.unlock_and_lock_upgrade();
+            assert(state == reading);
+            mut.unlock_upgrade_and_lock_shared();
+            assert(state == reading);
+            mut.unlock_shared();
+            ++count;
+        }
+    }
+    print("try_clockwise = ", count, '\n');
+}
+
+void try_for_clockwise()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_shared_for(boost::chrono::microseconds(5)))
+        {
+            assert(state == reading);
+            if (mut.try_unlock_shared_and_lock_for(boost::chrono::microseconds(5)))
+            {
+                state = writing;
+            }
+            else if (mut.try_unlock_shared_and_lock_upgrade_for(boost::chrono::microseconds(5)))
+            {
+                assert(state == reading);
+                mut.unlock_upgrade_and_lock();
+                state = writing;
+            }
+            else
+            {
+                mut.unlock_shared();
+                continue;
+            }
+            assert(state == writing);
+            state = reading;
+            mut.unlock_and_lock_upgrade();
+            assert(state == reading);
+            mut.unlock_upgrade_and_lock_shared();
+            assert(state == reading);
+            mut.unlock_shared();
+            ++count;
+        }
+    }
+    print("try_for_clockwise = ", count, '\n');
+}
+
+void try_counter_clockwise()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_upgrade())
+        {
+            assert(state == reading);
+            if (mut.try_unlock_upgrade_and_lock())
+            {
+                assert(state == reading);
+                state = writing;
+                assert(state == writing);
+                state = reading;
+                mut.unlock_and_lock_shared();
+                assert(state == reading);
+                mut.unlock_shared();
+                ++count;
+            }
+            else
+            {
+                mut.unlock_upgrade();
+            }
+        }
+    }
+    print("try_counter_clockwise = ", count, '\n');
+}
+
+void try_for_counter_clockwise()
+{
+    typedef boost::chrono::steady_clock Clock;
+    unsigned count = 0;
+    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
+    while (Clock::now() < until)
+    {
+        if (mut.try_lock_upgrade_for(boost::chrono::microseconds(5)))
+        {
+            assert(state == reading);
+            if (mut.try_unlock_upgrade_and_lock_for(boost::chrono::microseconds(5)))
+            {
+                assert(state == reading);
+                state = writing;
+                assert(state == writing);
+                state = reading;
+                mut.unlock_and_lock_shared();
+                assert(state == reading);
+                mut.unlock_shared();
+                ++count;
+            }
+            else
+            {
+                mut.unlock_upgrade();
+            }
+        }
+    }
+    print("try_for_counter_clockwise = ", count, '\n');
+}
+
+void
+test_upgrade_mutex()
+{
+    {
+        boost::thread t1(reader);
+        boost::thread t2(writer);
+        boost::thread t3(reader);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+    {
+        boost::thread t1(try_reader);
+        boost::thread t2(try_writer);
+        boost::thread t3(try_reader);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+    {
+        boost::thread t1(try_for_reader);
+        boost::thread t2(try_for_writer);
+        boost::thread t3(try_for_reader);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+    {
+        boost::thread t1(reader);
+        boost::thread t2(writer);
+        boost::thread t3(upgradable);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+    {
+        boost::thread t1(reader);
+        boost::thread t2(writer);
+        boost::thread t3(try_upgradable);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+    {
+        boost::thread t1(reader);
+        boost::thread t2(writer);
+        boost::thread t3(try_for_upgradable);
+        t1.join();
+        t2.join();
+        t3.join();
+    }
+    {
+        state = reading;
+        boost::thread t1(clockwise);
+        boost::thread t2(counter_clockwise);
+        boost::thread t3(clockwise);
+        boost::thread t4(counter_clockwise);
+        t1.join();
+        t2.join();
+        t3.join();
+        t4.join();
+    }
+    {
+        state = reading;
+        boost::thread t1(try_clockwise);
+        boost::thread t2(try_counter_clockwise);
+        t1.join();
+        t2.join();
+    }
+    {
+        state = reading;
+        boost::thread t1(try_for_clockwise);
+        boost::thread t2(try_for_counter_clockwise);
+        t1.join();
+        t2.join();
+    }
+}
+
+}
+
+namespace Assignment
+{
+
+class A
+{
+    typedef boost::upgrade_mutex            mutex_type;
+    typedef boost::shared_lock<mutex_type>  SharedLock;
+    typedef boost::upgrade_lock<mutex_type> UpgradeLock;
+    typedef boost::unique_lock<mutex_type>   Lock;
+
+    mutable mutex_type  mut_;
+    std::vector<double> data_;
+
+public:
+
+    A(const A& a)
+    {
+        SharedLock _(a.mut_);
+        data_ = a.data_;
+    }
+
+    A& operator=(const A& a)
+    {
+        if (this != &a)
+        {
+            Lock       this_lock(mut_, boost::defer_lock);
+            SharedLock that_lock(a.mut_, boost::defer_lock);
+            boost::lock(this_lock, that_lock);
+            data_ = a.data_;
+        }
+        return *this;
+    }
+
+    void swap(A& a)
+    {
+        Lock this_lock(mut_, boost::defer_lock);
+        Lock that_lock(a.mut_, boost::defer_lock);
+        boost::lock(this_lock, that_lock);
+        data_.swap(a.data_);
+    }
+
+    void average(A& a)
+    {
+        assert(data_.size() == a.data_.size());
+        assert(this != &a);
+
+        Lock        this_lock(mut_, boost::defer_lock);
+        UpgradeLock share_that_lock(a.mut_, boost::defer_lock);
+        boost::lock(this_lock, share_that_lock);
+
+        for (unsigned i = 0; i < data_.size(); ++i)
+            data_[i] = (data_[i] + a.data_[i]) / 2;
+
+        SharedLock share_this_lock(boost::move(this_lock));
+        Lock that_lock(boost::move(share_that_lock));
+        a.data_ = data_;
+    }
+};
+
+}  // Assignment
+
+void temp()
+{
+    using namespace boost;
+    static upgrade_mutex mut;
+    unique_lock<upgrade_mutex> ul(mut);
+    shared_lock<upgrade_mutex> sl;
+    sl = shared_lock<upgrade_mutex>(boost::move(ul));
+}
+
+int main()
+{
+  typedef boost::chrono::high_resolution_clock Clock;
+  typedef boost::chrono::duration<double> sec;
+  Clock::time_point t0 = Clock::now();
+
+  S::test_shared_mutex();
+  U::test_upgrade_mutex();
+  Clock::time_point t1 = Clock::now();
+  std::cout << sec(t1 - t0) << '\n';
+  return 0;
+}
+
--- a/example/tennis.cpp
+++ b/example/tennis.cpp
@@ -112,7 +112,7 @@ int main(int argc, char* argv[])
        std::cout << "---Noise ON..." << std::endl;
    }

-    for (int i = 0; i < 1000000; ++i)
+    for (int i = 0; i < 1000000000; ++i)
        cond.notify_all();

    {
--- a/include/boost/thread.hpp
+++ b/include/boost/thread.hpp
@@ -1,6 +1,6 @@
 // Copyright (C) 2001-2003
 // William E. Kempf
-// (C) Copyright 2008 Anthony Williams
+// (C) Copyright 2008-9 Anthony Williams
 //
 // 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)
@@ -21,5 +21,6 @@
 #include <boost/thread/locks.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/barrier.hpp>
+#include <boost/thread/future.hpp>

 #endif
--- a/include/boost/thread/barrier.hpp
+++ b/include/boost/thread/barrier.hpp
@@ -2,13 +2,14 @@
 // David Moore, William E. Kempf
 // Copyright (C) 2007-8 Anthony Williams
 //
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  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_BARRIER_JDM030602_HPP
 #define BOOST_BARRIER_JDM030602_HPP

 #include <boost/thread/detail/config.hpp>
+#include <boost/throw_exception.hpp>

 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
@@ -27,14 +28,14 @@ namespace boost
            : m_threshold(count), m_count(count), m_generation(0)
        {
            if (count == 0)
-                throw std::invalid_argument("count cannot be zero.");
+                boost::throw_exception(thread_exception(system::errc::invalid_argument, "barrier constructor: count cannot be zero."));
        }
-    
+
        bool wait()
        {
            boost::mutex::scoped_lock lock(m_mutex);
            unsigned int gen = m_generation;
-        
+
            if (--m_count == 0)
            {
                m_generation++;
--- a/include/boost/thread/cv_status.hpp
+++ b/include/boost/thread/cv_status.hpp
@@ -0,0 +1,26 @@
+//  cv_status.hpp
+//
+// Copyright (C) 2011 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_CV_STATUS_HPP
+#define BOOST_THREAD_CV_STATUS_HPP
+
+#include <boost/thread/detail/scoped_enum.hpp>
+
+namespace boost
+{
+
+  // enum class cv_status;
+  BOOST_SCOPED_ENUM_DECLARE_BEGIN(cv_status)
+  {
+    no_timeout,
+    timeout
+  }
+  BOOST_SCOPED_ENUM_DECLARE_END(cv_status)
+}
+
+#endif // header
--- a/include/boost/thread/detail/config.hpp
+++ b/include/boost/thread/detail/config.hpp
@@ -1,7 +1,7 @@
 // Copyright (C) 2001-2003
 // William E. Kempf
 //
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  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_CONFIG_WEK01032003_HPP
@@ -10,6 +10,40 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>

+#if !defined BOOST_THREAD_VERSION
+#define BOOST_THREAD_VERSION 1
+#else
+#if BOOST_THREAD_VERSION!=1  && BOOST_THREAD_VERSION!=2
+#error "BOOST_THREAD_VERSION must be 1 or 2"
+#endif
+#endif
+
+#if ! defined BOOST_THREAD_DONT_USE_SYSTEM
+#define BOOST_THREAD_USES_SYSTEM
+#endif
+
+#if ! defined BOOST_THREAD_DONT_USE_CHRONO && ! defined BOOST_THREAD_DONT_USE_SYSTEM
+#define BOOST_THREAD_USES_CHRONO
+#endif
+
+//#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
+//#define BOOST_THREAD_DONT_USE_MOVE
+//#endif
+
+//#define BOOST_THREAD_SHARED_MUTEX_PROVIDES_UPWARDS_CONVERSION
+//#define BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
+
+#if defined BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
+#define BOOST_THREAD_EXPLICIT_LOCK_CONVERSION explicit
+#else
+#define BOOST_THREAD_EXPLICIT_LOCK_CONVERSION
+#endif
+
+
+#if ! defined BOOST_THREAD_DONT_USE_MOVE
+#define BOOST_THREAD_USES_MOVE
+#endif
+
 #if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
 #  pragma warn -8008 // Condition always true/false
 #  pragma warn -8080 // Identifier declared but never used
@@ -19,8 +53,14 @@

 #include "platform.hpp"

+// provided for backwards compatibility, since this
+// macro was used for several releases by mistake.
+#if defined(BOOST_THREAD_DYN_DLL)
+# define BOOST_THREAD_DYN_LINK
+#endif
+
 // compatibility with the rest of Boost's auto-linking code:
-#if defined(BOOST_THREAD_DYN_DLL) || defined(BOOST_ALL_DYN_LINK)
+#if defined(BOOST_THREAD_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
 # undef  BOOST_THREAD_USE_LIB
 # define BOOST_THREAD_USE_DLL
 #endif
@@ -47,12 +87,18 @@

 #if defined(BOOST_HAS_DECLSPEC)
 #   if defined(BOOST_THREAD_BUILD_DLL) //Build dll
-#       define BOOST_THREAD_DECL __declspec(dllexport)
+#       define BOOST_THREAD_DECL BOOST_SYMBOL_EXPORT
+//#       define BOOST_THREAD_DECL __declspec(dllexport)
+
 #   elif defined(BOOST_THREAD_USE_DLL) //Use dll
-#       define BOOST_THREAD_DECL __declspec(dllimport)
+#       define BOOST_THREAD_DECL BOOST_SYMBOL_IMPORT
+//#       define BOOST_THREAD_DECL __declspec(dllimport)
 #   else
 #       define BOOST_THREAD_DECL
 #   endif
+#elif (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  define BOOST_THREAD_DECL BOOST_SYMBOL_VISIBLE
+
 #else
 #   define BOOST_THREAD_DECL
 #endif // BOOST_HAS_DECLSPEC
@@ -63,7 +109,7 @@
 #if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_THREAD_NO_LIB) && !defined(BOOST_THREAD_BUILD_DLL) && !defined(BOOST_THREAD_BUILD_LIB)
 //
 // Tell the autolink to link dynamically, this will get undef'ed by auto_link.hpp
-// once it's done with it: 
+// once it's done with it:
 //
 #if defined(BOOST_THREAD_USE_DLL)
 #   define BOOST_DYN_LINK
--- a/include/boost/thread/detail/move.hpp
+++ b/include/boost/thread/detail/move.hpp
@@ -6,13 +6,20 @@
 #ifndef BOOST_THREAD_MOVE_HPP
 #define BOOST_THREAD_MOVE_HPP

+#include <boost/thread/detail/config.hpp>
+#ifndef BOOST_NO_SFINAE
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#endif
+
+#include <boost/move/move.hpp>

 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
+
    namespace detail
    {
        template<typename T>
@@ -37,18 +44,21 @@ namespace boost
        };
    }

+#ifndef BOOST_NO_SFINAE
    template<typename T>
-    typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, detail::thread_move_t<T> >::type move(T& t)
+    typename enable_if<boost::is_convertible<T&,boost::detail::thread_move_t<T> >, boost::detail::thread_move_t<T> >::type move(T& t)
+    {
+        return boost::detail::thread_move_t<T>(t);
+    }
+#endif
+
+    template<typename T>
+    boost::detail::thread_move_t<T> move(boost::detail::thread_move_t<T> t)
    {
        return t;
    }
-    
-    template<typename T>
-    detail::thread_move_t<T> move(detail::thread_move_t<T> t)
-    {
-        return t;
-    }
-    
+
+
 }

 #include <boost/config/abi_suffix.hpp>
--- a/include/boost/thread/detail/platform.hpp
+++ b/include/boost/thread/detail/platform.hpp
@@ -29,7 +29,7 @@
 #  define BOOST_THREAD_HPUX
 #elif defined(__CYGWIN__)
 #  define BOOST_THREAD_CYGWIN
-#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+#elif (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(BOOST_DISABLE_WIN32)
 #  define BOOST_THREAD_WIN32
 #elif defined(__BEOS__)
 #  define BOOST_THREAD_BEOS
@@ -42,9 +42,9 @@
 #elif defined(__QNXNTO__)
 #  define BOOST_THREAD_QNXNTO
 #elif defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE)
-#	if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_THREAD_POSIX)
-#		define BOOST_THREAD_POSIX
-#	endif
+#       if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_THREAD_POSIX)
+#               define BOOST_THREAD_POSIX
+#       endif
 #endif

 // For every supported platform add a new entry into the dispatch table below.
--- a/include/boost/thread/detail/scoped_enum.hpp
+++ b/include/boost/thread/detail/scoped_enum.hpp
@@ -0,0 +1,113 @@
+// Copyright (C) 2012
+// 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_DETAIL_SCOPED_ENUM_HPP
+#define BOOST_THREAD_DETAIL_SCOPED_ENUM_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+namespace boost
+{
+
+#ifdef BOOST_NO_SCOPED_ENUMS
+  template <typename NT>
+  struct underlying_type
+  {
+    typedef typename NT::underlying_type type;
+  };
+
+  template <typename UT, typename NT>
+  UT underlying_cast(NT v)
+  {
+    return v.underlying();
+  }
+
+  template <typename EC>
+  inline
+  typename EC::enum_type native_value(EC e)
+  {
+    return e.native();
+  }
+
+#else  // BOOST_NO_SCOPED_ENUMS
+
+  template <typename NT>
+  struct underlying_type
+  {
+    //typedef typename std::underlying_type<NT>::type type;
+  };
+
+  template <typename UT, typename NT>
+  UT underlying_cast(NT v)
+  {
+    return static_cast<UT>(v);
+  }
+
+  template <typename EC>
+  inline
+  EC native_value(EC e)
+  {
+    return e;
+ }
+
+#endif
+}
+
+
+#ifdef BOOST_NO_SCOPED_ENUMS
+
+#ifndef BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
+     explicit operator underlying_type() const { return underlying(); }
+
+#else
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR
+
+#endif
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(NT, UT) \
+  struct NT { \
+    typedef UT underlying_type; \
+    enum enum_type
+
+#define BOOST_SCOPED_ENUM_DECLARE_END(NT) \
+    ; \
+    NT()  {} \
+    NT(enum_type v) : v_(v) {} \
+    explicit NT(underlying_type v) : v_(v) {} \
+    underlying_type underlying() const { return v_; } \
+    enum_type native() const { return enum_type(v_); } \
+    BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
+    friend bool operator ==(NT lhs, enum_type rhs)  { return enum_type(lhs.v_)==rhs; } \
+    friend bool operator ==(enum_type lhs, NT rhs)  { return lhs==enum_type(rhs.v_); } \
+    friend bool operator !=(NT lhs, enum_type rhs)  { return enum_type(lhs.v_)!=rhs; } \
+    friend bool operator !=(enum_type lhs, NT rhs)  { return lhs!=enum_type(rhs.v_); } \
+  private: \
+    underlying_type v_; \
+  };
+
+#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(NT) \
+  BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(NT,int)
+
+#define BOOST_SCOPED_ENUM_NATIVE(NT) NT::enum_type
+#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(NT) struct NT
+
+#else  // BOOST_NO_SCOPED_ENUMS
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(NT,UT) enum class NT:UT
+#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(NT) enum class NT
+#define BOOST_SCOPED_ENUM_DECLARE_END(NT) ;
+
+#define BOOST_SCOPED_ENUM_NATIVE(NT) NT
+#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(NT) enum class NT
+
+#endif  // BOOST_NO_SCOPED_ENUMS
+
+
+#endif // BOOST_THREAD_DETAIL_SCOPED_ENUM_HPP
--- a/include/boost/thread/detail/thread.hpp
+++ b/include/boost/thread/detail/thread.hpp
@@ -3,11 +3,19 @@
 // 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)
-// (C) Copyright 2007-8 Anthony Williams
- 
+// (C) Copyright 2007-10 Anthony Williams
+// (C) Copyright 20011-12 Vicente J. Botet Escriba
+
+#include <boost/thread/detail/config.hpp>
 #include <boost/thread/exceptions.hpp>
+#ifndef BOOST_NO_IOSTREAM
 #include <ostream>
+#endif
+#if defined BOOST_THREAD_USES_MOVE
+#include <boost/move/move.hpp>
+#else
 #include <boost/thread/detail/move.hpp>
+#endif
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/thread/detail/thread_heap_alloc.hpp>
@@ -22,6 +30,14 @@
 #include <memory>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/remove_reference.hpp>
+#include <boost/io/ios_state.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/decay.hpp>
+#include <boost/functional/hash.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -32,6 +48,19 @@

 namespace boost
 {
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+  namespace thread_detail
+  {
+      template <class T>
+      typename decay<T>::type
+      decay_copy(T&& t)
+      {
+          return boost::forward<T>(t);
+      }
+  }
+#endif
+
    namespace detail
    {
        template<typename F>
@@ -39,18 +68,28 @@ namespace boost
            public detail::thread_data_base
        {
        public:
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
            thread_data(F&& f_):
-                f(static_cast<F&&>(f_))
+              f(boost::forward<F>(f_))
            {}
+// This overloading must be removed if we want the packaged_task's tests to pass.
+//            thread_data(F& f_):
+//                f(f_)
+//            {}
 #else
            thread_data(F f_):
                f(f_)
            {}
+#if defined BOOST_THREAD_USES_MOVE
+            thread_data(boost::rv<F>& f_):
+                f(boost::move(f_))
+            {}
+#else
            thread_data(detail::thread_move_t<F> f_):
                f(f_)
            {}
-#endif            
+#endif
+#endif
            void run()
            {
                f();
@@ -75,7 +114,7 @@ namespace boost
            thread_data(boost::reference_wrapper<F> f_):
                f(f_)
            {}
-            
+
            void run()
            {
                f();
@@ -94,40 +133,53 @@ namespace boost
            thread_data(const boost::reference_wrapper<F> f_):
                f(f_)
            {}
-            
+
            void run()
            {
                f();
            }
        };
    }
-    
+
    class BOOST_THREAD_DECL thread
    {
+    public:
+      //typedef int boost_move_emulation_t;
+      typedef thread_attributes attributes;
+
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+    public:
+      thread(thread const&) = delete;
+      thread& operator=(thread const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+    private:
+      thread(thread&);
+      thread& operator=(thread&);
+#endif // BOOST_NO_DELETED_FUNCTIONS
    private:
-        thread(thread&);
-        thread& operator=(thread&);

        void release_handle();
-        
-        mutable boost::mutex thread_info_mutex;
+
        detail::thread_data_ptr thread_info;

        void start_thread();
-        
+        void start_thread(const attributes& attr);
+
        explicit thread(detail::thread_data_ptr data);

-        detail::thread_data_ptr get_thread_info() const;
+        detail::thread_data_ptr get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const;

-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
        template<typename F>
        static inline detail::thread_data_ptr make_thread_info(F&& f)
        {
-            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(static_cast<F&&>(f)));
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(
+                boost::forward<F>(f)));
        }
        static inline detail::thread_data_ptr make_thread_info(void (*f)())
        {
-            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(f));
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(
+                boost::forward<void(*)()>(f)));
        }
 #else
        template<typename F>
@@ -135,43 +187,108 @@ namespace boost
        {
            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
        }
+#if defined BOOST_THREAD_USES_MOVE
+        template<typename F>
+        static inline detail::thread_data_ptr make_thread_info(boost::rv<F>& f)
+        {
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(boost::move(f)));
+        }
+
+#else
        template<typename F>
        static inline detail::thread_data_ptr make_thread_info(boost::detail::thread_move_t<F> f)
        {
            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
        }

-        struct dummy;
 #endif
+#endif
+        struct dummy;
    public:
-        thread();
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
+        thread(const volatile thread&);
+#endif
+        thread() BOOST_NOEXCEPT;
        ~thread();

-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
+#ifdef BOOST_MSVCXX
        template <class F>
-        thread(F&& f):
+        explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
            thread_info(make_thread_info(static_cast<F&&>(f)))
        {
            start_thread();
        }
+#else
+        template <
+          class F
+          //, class Dummy = typename disable_if< is_same<typename decay<F>::type, thread> >::type
+        >
+        explicit thread(F&& f
+        , typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0
+        ):
+          thread_info(make_thread_info(thread_detail::decay_copy(boost::forward<F>(f))))
+        {
+            start_thread();
+        }
+        template <
+          class F
+          //, class Dummy = typename disable_if< is_same<typename decay<F>::type, thread> >::type
+        >
+        thread(attributes& attrs, F&& f
+        , typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0
+        ):
+          thread_info(make_thread_info(thread_detail::decay_copy(boost::forward<F>(f))))
+        {
+            start_thread(attrs);
+        }
+#endif

-        thread(thread&& other)
+        thread(thread&& other) BOOST_NOEXCEPT
        {
            thread_info.swap(other.thread_info);
        }
-        
-        thread& operator=(thread&& other)
+
+        thread& operator=(thread&& other) BOOST_NOEXCEPT
        {
            thread_info=other.thread_info;
            other.thread_info.reset();
            return *this;
        }

-        thread&& move()
+//        thread&& move()
+//        {
+//            return static_cast<thread&&>(*this);
+//        }
+
+#else
+#ifdef BOOST_NO_SFINAE
+        template <class F>
+        explicit thread(F f):
+            thread_info(make_thread_info(f))
        {
-            return static_cast<thread&&>(*this);
+            start_thread();
+        }
+        template <class F>
+        thread(attributes& attrs, F f):
+            thread_info(make_thread_info(f))
+        {
+            start_thread(attrs);
+        }
+#else
+#if defined BOOST_THREAD_USES_MOVE
+        template <class F>
+        explicit thread(F f,typename disable_if<boost::is_convertible<F&,boost::rv<F>& >, dummy* >::type=0):
+            thread_info(make_thread_info(f))
+        {
+            start_thread();
+        }
+        template <class F>
+        thread(attributes& attrs, F f,typename disable_if<boost::is_convertible<F&,boost::rv<F>& >, dummy* >::type=0):
+            thread_info(make_thread_info(f))
+        {
+            start_thread(attrs);
        }
-        
 #else
        template <class F>
        explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
@@ -179,42 +296,132 @@ namespace boost
        {
            start_thread();
        }
-        
        template <class F>
-        thread(detail::thread_move_t<F> f):
+        thread(attributes& attrs, F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
+            thread_info(make_thread_info(f))
+        {
+            start_thread(attrs);
+        }
+#endif
+#endif
+
+#if defined BOOST_THREAD_USES_MOVE
+        template <class F>
+        explicit thread(boost::rv<F>& f):
+            thread_info(make_thread_info(boost::move(f)))
+        {
+            start_thread();
+        }
+
+
+//        explicit thread(void (*f)()):
+//            thread_info(make_thread_info(f))
+//        {
+//            start_thread();
+//        }
+//
+//        template <class F>
+//        explicit thread(BOOST_FWD_REF(F) f):
+//            thread_info(make_thread_info(boost::forward<F>(f)))
+//        {
+//            start_thread();
+//        }
+
+        template <class F>
+        thread(attributes& attrs, boost::rv<F>& f):
+            thread_info(make_thread_info(boost::move(f)))
+        {
+            start_thread(attrs);
+        }
+
+
+        thread(boost::rv<thread>& x)
+        //thread(BOOST_RV_REF(thread) x)
+        {
+            thread_info=x.thread_info;
+            x.thread_info.reset();
+        }
+#else
+        template <class F>
+        explicit thread(detail::thread_move_t<F> f):
            thread_info(make_thread_info(f))
        {
            start_thread();
        }

+        template <class F>
+        thread(attributes& attrs, detail::thread_move_t<F> f):
+            thread_info(make_thread_info(f))
+        {
+            start_thread(attrs);
+        }
+
        thread(detail::thread_move_t<thread> x)
        {
            thread_info=x->thread_info;
            x->thread_info.reset();
        }
-        
+#endif
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
+        thread& operator=(thread x)
+        {
+            swap(x);
+            return *this;
+        }
+#else
+#if defined BOOST_THREAD_USES_MOVE
+        thread& operator=(boost::rv<thread>& x)
+        {
+            thread new_thread(boost::move(x));
+            swap(new_thread);
+            return *this;
+        }
+#else
        thread& operator=(detail::thread_move_t<thread> x)
        {
            thread new_thread(x);
            swap(new_thread);
            return *this;
        }
-        
+#endif
+#endif
+
+#if defined BOOST_THREAD_USES_MOVE
+        ::boost::rv<thread>& move()
+        {
+          return *static_cast< ::boost::rv<thread>* >(this);
+        }
+        const ::boost::rv<thread>& move() const
+        {
+          return *static_cast<const ::boost::rv<thread>* >(this);
+        }
+
+      operator ::boost::rv<thread>&()
+      {
+        return *static_cast< ::boost::rv<thread>* >(this);
+      }
+      operator const ::boost::rv<thread>&() const
+      {
+        return *static_cast<const ::boost::rv<thread>* >(this);
+      }
+#else
        operator detail::thread_move_t<thread>()
        {
            return move();
        }
-        
+
        detail::thread_move_t<thread> move()
        {
            detail::thread_move_t<thread> x(*this);
            return x;
        }
+#endif

 #endif

        template <class F,class A1>
-        thread(F f,A1 a1):
+        thread(F f,A1 a1,typename disable_if<boost::is_convertible<F&,thread_attributes >, dummy* >::type=0):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
        {
            start_thread();
@@ -275,28 +482,99 @@ namespace boost
            start_thread();
        }

-        void swap(thread& x)
+        void swap(thread& x) BOOST_NOEXCEPT
        {
            thread_info.swap(x.thread_info);
        }

-        class id;
-        id get_id() const;
+        class BOOST_SYMBOL_VISIBLE id;
+        id get_id() const BOOST_NOEXCEPT;


-        bool joinable() const;
+        bool joinable() const BOOST_NOEXCEPT;
        void join();
-        bool timed_join(const system_time& wait_until);
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+        bool timed_join(const system_time& abs_time);
+
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_join_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_join_until(const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
+          typename Clock::time_point  c_now = Clock::now();
+          return try_join_until(s_now + ceil<nanoseconds>(t - c_now));
+        }
+        template <class Duration>
+        bool try_join_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
+          return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
+        }
+        bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp);
+#endif
+    public:
+
+#else
+        bool timed_join(const system_time& abs_time) {
+          struct timespec const ts=detail::get_timespec(abs_time);
+          return do_try_join_until(ts);
+        }
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_join_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_join_until(const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
+          typename Clock::time_point  c_now = Clock::now();
+          return try_join_until(s_now + ceil<nanoseconds>(t - c_now));
+        }
+        template <class Duration>
+        bool try_join_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
+          return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
+        }
+        bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
+        {
+          using namespace chrono;
+          nanoseconds d = tp.time_since_epoch();
+          timespec ts;
+          seconds s = duration_cast<seconds>(d);
+          ts.tv_sec = static_cast<long>(s.count());
+          ts.tv_nsec = static_cast<long>((d - s).count());
+          return do_try_join_until(ts);
+        }
+#endif
+      private:
+        bool do_try_join_until(struct timespec const &timeout);
+      public:
+
+#endif

        template<typename TimeDuration>
        inline bool timed_join(TimeDuration const& rel_time)
        {
            return timed_join(get_system_time()+rel_time);
        }
+
        void detach();

-        static unsigned hardware_concurrency();
+        static unsigned hardware_concurrency() BOOST_NOEXCEPT;

+#define BOOST_THREAD_DEFINES_THREAD_NATIVE_HANDLE
        typedef detail::thread_data_base::native_handle_type native_handle_type;
        native_handle_type native_handle();

@@ -304,11 +582,11 @@ namespace boost
        bool operator==(const thread& other) const;
        bool operator!=(const thread& other) const;

-        static inline void yield()
+        static inline void yield() BOOST_NOEXCEPT
        {
            this_thread::yield();
        }
-        
+
        static inline void sleep(const system_time& xt)
        {
            this_thread::sleep(xt);
@@ -319,156 +597,193 @@ namespace boost
        bool interruption_requested() const;
    };

-    inline void swap(thread& lhs,thread& rhs)
+    inline void swap(thread& lhs,thread& rhs) BOOST_NOEXCEPT
    {
        return lhs.swap(rhs);
    }
-    
-#ifdef BOOST_HAS_RVALUE_REFS
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+    inline thread&& move(thread& t)
+    {
+        return static_cast<thread&&>(t);
+    }
    inline thread&& move(thread&& t)
    {
-        return t;
+        return static_cast<thread&&>(t);
    }
 #else
+#if !defined BOOST_THREAD_USES_MOVE
    inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
    {
        return t;
    }
+#endif
+#endif
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
+#if !defined BOOST_THREAD_USES_MOVE
+    template <>
+    struct has_move_emulation_enabled_aux<thread>
+      : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+    {};
+#endif
 #endif

    namespace this_thread
    {
-        class BOOST_THREAD_DECL disable_interruption
-        {
-            disable_interruption(const disable_interruption&);
-            disable_interruption& operator=(const disable_interruption&);
-            
-            bool interruption_was_enabled;
-            friend class restore_interruption;
-        public:
-            disable_interruption();
-            ~disable_interruption();
-        };
-
-        class BOOST_THREAD_DECL restore_interruption
-        {
-            restore_interruption(const restore_interruption&);
-            restore_interruption& operator=(const restore_interruption&);
-        public:
-            explicit restore_interruption(disable_interruption& d);
-            ~restore_interruption();
-        };
-
-        thread::id BOOST_THREAD_DECL get_id();
+        thread::id BOOST_THREAD_DECL get_id() BOOST_NOEXCEPT;

        void BOOST_THREAD_DECL interruption_point();
        bool BOOST_THREAD_DECL interruption_enabled();
        bool BOOST_THREAD_DECL interruption_requested();

-        inline void sleep(xtime const& abs_time)
+        inline BOOST_SYMBOL_VISIBLE void sleep(xtime const& abs_time)
        {
            sleep(system_time(abs_time));
        }
    }

-    class thread::id
+    class BOOST_SYMBOL_VISIBLE thread::id
    {
    private:
+        friend inline
+        std::size_t
+        hash_value(const thread::id &v)
+        {
+          return hash_value(v.thread_data.get());
+        }
+
        detail::thread_data_ptr thread_data;
-            
+
        id(detail::thread_data_ptr thread_data_):
            thread_data(thread_data_)
        {}
        friend class thread;
-        friend id this_thread::get_id();
+        friend id BOOST_THREAD_DECL this_thread::get_id() BOOST_NOEXCEPT;
    public:
-        id():
+        id() BOOST_NOEXCEPT:
            thread_data()
        {}
-            
-        bool operator==(const id& y) const
+
+        id(const id& other) BOOST_NOEXCEPT :
+            thread_data(other.thread_data)
+        {}
+
+        bool operator==(const id& y) const BOOST_NOEXCEPT
        {
            return thread_data==y.thread_data;
        }
-        
-        bool operator!=(const id& y) const
+
+        bool operator!=(const id& y) const BOOST_NOEXCEPT
        {
            return thread_data!=y.thread_data;
        }
-        
-        bool operator<(const id& y) const
+
+        bool operator<(const id& y) const BOOST_NOEXCEPT
        {
            return thread_data<y.thread_data;
        }
-        
-        bool operator>(const id& y) const
+
+        bool operator>(const id& y) const BOOST_NOEXCEPT
        {
            return y.thread_data<thread_data;
        }
-        
-        bool operator<=(const id& y) const
+
+        bool operator<=(const id& y) const BOOST_NOEXCEPT
        {
            return !(y.thread_data<thread_data);
        }
-        
-        bool operator>=(const id& y) const
+
+        bool operator>=(const id& y) const BOOST_NOEXCEPT
        {
            return !(thread_data<y.thread_data);
        }

+#ifndef BOOST_NO_IOSTREAM
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
        template<class charT, class traits>
-        friend std::basic_ostream<charT, traits>& 
+        friend BOOST_SYMBOL_VISIBLE
+  std::basic_ostream<charT, traits>&
        operator<<(std::basic_ostream<charT, traits>& os, const id& x)
        {
            if(x.thread_data)
            {
-                return os<<x.thread_data;
+                io::ios_flags_saver  ifs( os );
+                return os<< std::hex << x.thread_data;
            }
            else
            {
                return os<<"{Not-any-thread}";
            }
        }
+#else
+        template<class charT, class traits>
+        BOOST_SYMBOL_VISIBLE
+  std::basic_ostream<charT, traits>&
+        print(std::basic_ostream<charT, traits>& os) const
+        {
+            if(thread_data)
+            {
+                return os<<thread_data;
+            }
+            else
+            {
+                return os<<"{Not-any-thread}";
+            }
+        }
+
+#endif
+#endif
    };

+#if !defined(BOOST_NO_IOSTREAM) && defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    template<class charT, class traits>
+    BOOST_SYMBOL_VISIBLE
+    std::basic_ostream<charT, traits>&
+    operator<<(std::basic_ostream<charT, traits>& os, const thread::id& x)
+    {
+        return x.print(os);
+    }
+#endif
+
    inline bool thread::operator==(const thread& other) const
    {
        return get_id()==other.get_id();
    }
-    
+
    inline bool thread::operator!=(const thread& other) const
    {
        return get_id()!=other.get_id();
    }
-        
+
    namespace detail
    {
        struct thread_exit_function_base
        {
            virtual ~thread_exit_function_base()
            {}
-            virtual void operator()() const=0;
+            virtual void operator()()=0;
        };
-        
+
        template<typename F>
        struct thread_exit_function:
            thread_exit_function_base
        {
            F f;
-            
+
            thread_exit_function(F f_):
                f(f_)
            {}
-            
-            void operator()() const
+
+            void operator()()
            {
                f();
            }
        };
-        
-        void add_thread_exit_function(thread_exit_function_base*);
+
+        void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
    }
-    
+
    namespace this_thread
    {
        template<typename F>
@@ -478,83 +793,6 @@ namespace boost
            detail::add_thread_exit_function(thread_exit_func);
        }
    }
-
-    class thread_group:
-        private noncopyable
-    {
-    public:
-        ~thread_group()
-        {
-            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
-                it!=end;
-                ++it)
-            {
-                delete *it;
-            }
-        }
-
-        template<typename F>
-        thread* create_thread(F threadfunc)
-        {
-            boost::lock_guard<mutex> guard(m);
-            std::auto_ptr<thread> new_thread(new thread(threadfunc));
-            threads.push_back(new_thread.get());
-            return new_thread.release();
-        }
-        
-        void add_thread(thread* thrd)
-        {
-            if(thrd)
-            {
-                boost::lock_guard<mutex> guard(m);
-                threads.push_back(thrd);
-            }
-        }
-            
-        void remove_thread(thread* thrd)
-        {
-            boost::lock_guard<mutex> guard(m);
-            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
-            if(it!=threads.end())
-            {
-                threads.erase(it);
-            }
-        }
-        
-        void join_all()
-        {
-            boost::lock_guard<mutex> guard(m);
-            
-            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
-                it!=end;
-                ++it)
-            {
-                (*it)->join();
-            }
-        }
-        
-        void interrupt_all()
-        {
-            boost::lock_guard<mutex> guard(m);
-            
-            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
-                it!=end;
-                ++it)
-            {
-                (*it)->interrupt();
-            }
-        }
-        
-        size_t size() const
-        {
-            boost::lock_guard<mutex> guard(m);
-            return threads.size();
-        }
-        
-    private:
-        std::list<thread*> threads;
-        mutable mutex m;
-    };
 }

 #ifdef BOOST_MSVC
--- a/include/boost/thread/detail/thread_group.hpp
+++ b/include/boost/thread/detail/thread_group.hpp
@@ -0,0 +1,108 @@
+#ifndef BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
+#define BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
+// 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)
+// (C) Copyright 2007-9 Anthony Williams
+
+#include <list>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/mutex.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+
+namespace boost
+{
+    class thread_group
+    {
+    private:
+        thread_group(thread_group const&);
+        thread_group& operator=(thread_group const&);        
+    public:
+        thread_group() {}
+        ~thread_group()
+        {
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                delete *it;
+            }
+        }
+
+        template<typename F>
+        thread* create_thread(F threadfunc)
+        {
+            boost::lock_guard<shared_mutex> guard(m);
+            std::auto_ptr<thread> new_thread(new thread(threadfunc));
+            threads.push_back(new_thread.get());
+            return new_thread.release();
+        }
+        
+        void add_thread(thread* thrd)
+        {
+            if(thrd)
+            {
+                boost::lock_guard<shared_mutex> guard(m);
+                threads.push_back(thrd);
+            }
+        }
+            
+        void remove_thread(thread* thrd)
+        {
+            boost::lock_guard<shared_mutex> guard(m);
+            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
+            if(it!=threads.end())
+            {
+                threads.erase(it);
+            }
+        }
+        
+        void join_all()
+        {
+            boost::shared_lock<shared_mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->join();
+            }
+        }
+        
+        void interrupt_all()
+        {
+            boost::shared_lock<shared_mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->interrupt();
+            }
+        }
+        
+        size_t size() const
+        {
+            boost::shared_lock<shared_mutex> guard(m);
+            return threads.size();
+        }
+        
+    private:
+        std::list<thread*> threads;
+        mutable shared_mutex m;
+    };
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif
--- a/include/boost/thread/detail/thread_interruption.hpp
+++ b/include/boost/thread/detail/thread_interruption.hpp
@@ -0,0 +1,35 @@
+#ifndef BOOST_THREAD_DETAIL_THREAD_INTERRUPTION_HPP
+#define BOOST_THREAD_DETAIL_THREAD_INTERRUPTION_HPP
+// 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)
+// (C) Copyright 2007-9 Anthony Williams
+
+namespace boost
+{
+    namespace this_thread
+    {
+        class BOOST_THREAD_DECL disable_interruption
+        {
+            disable_interruption(const disable_interruption&);
+            disable_interruption& operator=(const disable_interruption&);
+            
+            bool interruption_was_enabled;
+            friend class restore_interruption;
+        public:
+            disable_interruption();
+            ~disable_interruption();
+        };
+
+        class BOOST_THREAD_DECL restore_interruption
+        {
+            restore_interruption(const restore_interruption&);
+            restore_interruption& operator=(const restore_interruption&);
+        public:
+            explicit restore_interruption(disable_interruption& d);
+            ~restore_interruption();
+        };
+    }
+}
+
+#endif
--- a/include/boost/thread/detail/tss_hooks.hpp
+++ b/include/boost/thread/detail/tss_hooks.hpp
@@ -12,27 +12,9 @@

 #if defined(BOOST_HAS_WINTHREADS)

-    typedef void (__cdecl *thread_exit_handler)(void);
-
-    extern "C" BOOST_THREAD_DECL int at_thread_exit(
-        thread_exit_handler exit_handler
-        );
-        //Add a function to the list of functions that will
-            //be called when a thread is about to exit.
-        //Currently only implemented for Win32, but should
-            //later be implemented for all platforms.
-        //Used by Win32 implementation of Boost.Threads
-            //tss to perform cleanup.
-        //Like the C runtime library atexit() function,
-            //which it mimics, at_thread_exit() returns
-            //zero if successful and a nonzero
-            //value if an error occurs.
-
-#endif //defined(BOOST_HAS_WINTHREADS)
-
-#if defined(BOOST_HAS_WINTHREADS)
-
-    extern "C" BOOST_THREAD_DECL void on_process_enter(void);
+namespace boost
+{
+    BOOST_THREAD_DECL void __cdecl on_process_enter(void);
        //Function to be called when the exe or dll
            //that uses Boost.Threads first starts
            //or is first loaded.
@@ -42,7 +24,7 @@
            //a method for doing so has been discovered.
        //May be omitted; may be called multiple times.

-    extern "C" BOOST_THREAD_DECL void on_process_exit(void);
+    BOOST_THREAD_DECL void __cdecl on_process_exit(void);
        //Function to be called when the exe or dll
            //that uses Boost.Threads first starts
            //or is first loaded.
@@ -52,7 +34,7 @@
            //a method for doing so has been discovered.
        //Must not be omitted; may be called multiple times.

-    extern "C" BOOST_THREAD_DECL void on_thread_enter(void);
+    BOOST_THREAD_DECL void __cdecl on_thread_enter(void);
        //Function to be called just after a thread starts
            //in an exe or dll that uses Boost.Threads.
        //Must be called in the context of the thread
@@ -61,7 +43,7 @@
            //a method for doing so has been discovered.
        //May be omitted; may be called multiple times.

-    extern "C" BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
+    BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
        //Function to be called just be fore a thread ends
            //in an exe or dll that uses Boost.Threads.
        //Must be called in the context of the thread
@@ -70,10 +52,11 @@
            //a method for doing so has been discovered.
        //Must not be omitted; may be called multiple times.
    
-    extern "C" void tss_cleanup_implemented(void);
+    void tss_cleanup_implemented();
        //Dummy function used both to detect whether tss cleanup
            //cleanup has been implemented and to force
            //it to be linked into the Boost.Threads library.
+}

 #endif //defined(BOOST_HAS_WINTHREADS)

--- a/include/boost/thread/exceptions.hpp
+++ b/include/boost/thread/exceptions.hpp
@@ -1,8 +1,8 @@
 // Copyright (C) 2001-2003
 // William E. Kempf
-// Copyright (C) 2007-8 Anthony Williams
+// Copyright (C) 2007-9 Anthony Williams
 //
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  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_EXCEPTIONS_PDM070801_H
@@ -18,97 +18,205 @@

 #include <string>
 #include <stdexcept>
+#include <boost/system/system_error.hpp>
+#include <boost/system/error_code.hpp>
+

 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {

-    class BOOST_THREAD_DECL thread_interrupted
+    class BOOST_SYMBOL_VISIBLE thread_interrupted
    {};

-class BOOST_THREAD_DECL thread_exception : public std::exception
-{
-protected:
-    thread_exception();
-    thread_exception(int sys_err_code);
-
-public:
-    ~thread_exception() throw();
-
-    int native_error() const;
-
-private:
-    int m_sys_err;
-};
-
-    class condition_error:
-        public std::exception
+    class BOOST_SYMBOL_VISIBLE thread_exception:
+        public system::system_error
+        //public std::exception
    {
+          typedef system::system_error base_type;
    public:
-        const char* what() const throw()
+        thread_exception()
+          : base_type(0,system::system_category())
+        {}
+
+        thread_exception(int sys_error_code)
+          : base_type(sys_error_code, system::system_category())
+        {}
+
+        thread_exception( int ev, const char * what_arg )
+        : base_type(system::error_code(ev, system::system_category()), what_arg)
        {
-            return "Condition error";
        }
+        thread_exception( int ev, const std::string & what_arg )
+        : base_type(system::error_code(ev, system::system_category()), what_arg)
+        {
+        }
+
+        ~thread_exception() throw()
+        {}
+
+
+        int native_error() const
+        {
+            return code().value();
+        }
+
    };
-    

-class BOOST_THREAD_DECL lock_error : public thread_exception
-{
-public:
-    lock_error();
-    lock_error(int sys_err_code);
-    ~lock_error() throw();
+    class BOOST_SYMBOL_VISIBLE condition_error:
+        public system::system_error
+        //public std::exception
+    {
+          typedef system::system_error base_type;
+    public:
+          condition_error()
+          : base_type(system::error_code(0, system::system_category()), "Condition error")
+          {}
+          condition_error( int ev )
+          : base_type(system::error_code(ev, system::system_category()), "Condition error")
+          {
+          }
+          condition_error( int ev, const char * what_arg )
+          : base_type(system::error_code(ev, system::system_category()), what_arg)
+          {
+          }
+          condition_error( int ev, const std::string & what_arg )
+          : base_type(system::error_code(ev, system::system_category()), what_arg)
+          {
+          }
+    };

-    virtual const char* what() const throw();
-};

-class BOOST_THREAD_DECL thread_resource_error : public thread_exception
-{
-public:
-    thread_resource_error();
-    thread_resource_error(int sys_err_code);
-    ~thread_resource_error() throw();
+    class BOOST_SYMBOL_VISIBLE lock_error:
+        public thread_exception
+    {
+          typedef thread_exception base_type;
+    public:
+        lock_error()
+        : base_type(0, "boost::lock_error")
+        {}

-    virtual const char* what() const throw();
-};
+        lock_error( int ev )
+        : base_type(ev, "boost::lock_error")
+        {
+        }
+        lock_error( int ev, const char * what_arg )
+        : base_type(ev, what_arg)
+        {
+        }
+        lock_error( int ev, const std::string & what_arg )
+        : base_type(ev, what_arg)
+        {
+        }

-class BOOST_THREAD_DECL unsupported_thread_option : public thread_exception
-{
-public:
-    unsupported_thread_option();
-    unsupported_thread_option(int sys_err_code);
-    ~unsupported_thread_option() throw();
+        ~lock_error() throw()
+        {}

-    virtual const char* what() const throw();
-};
+    };

-class BOOST_THREAD_DECL invalid_thread_argument : public thread_exception
-{
-public:
-    invalid_thread_argument();
-    invalid_thread_argument(int sys_err_code);
-    ~invalid_thread_argument() throw();
+    class BOOST_SYMBOL_VISIBLE thread_resource_error:
+        public thread_exception
+    {
+          typedef thread_exception base_type;
+    public:
+          thread_resource_error()
+          : base_type(system::errc::resource_unavailable_try_again, "boost::thread_resource_error")
+          {}

-    virtual const char* what() const throw();
-};
+          thread_resource_error( int ev )
+          : base_type(ev, "boost::thread_resource_error")
+          {
+          }
+          thread_resource_error( int ev, const char * what_arg )
+          : base_type(ev, what_arg)
+          {
+          }
+          thread_resource_error( int ev, const std::string & what_arg )
+          : base_type(ev, what_arg)
+          {
+          }

-class BOOST_THREAD_DECL thread_permission_error : public thread_exception
-{
-public:
-    thread_permission_error();
-    thread_permission_error(int sys_err_code);
-    ~thread_permission_error() throw();

-    virtual const char* what() const throw();
-};
+        ~thread_resource_error() throw()
+        {}
+
+    };
+
+    class BOOST_SYMBOL_VISIBLE unsupported_thread_option:
+        public thread_exception
+    {
+          typedef thread_exception base_type;
+    public:
+          unsupported_thread_option()
+          : base_type(system::errc::invalid_argument, "boost::unsupported_thread_option")
+          {}
+
+          unsupported_thread_option( int ev )
+          : base_type(ev, "boost::unsupported_thread_option")
+          {
+          }
+          unsupported_thread_option( int ev, const char * what_arg )
+          : base_type(ev, what_arg)
+          {
+          }
+          unsupported_thread_option( int ev, const std::string & what_arg )
+          : base_type(ev, what_arg)
+          {
+          }
+
+    };
+
+    class BOOST_SYMBOL_VISIBLE invalid_thread_argument:
+        public thread_exception
+    {
+          typedef thread_exception base_type;
+    public:
+        invalid_thread_argument()
+        : base_type(system::errc::invalid_argument, "boost::invalid_thread_argument")
+        {}
+
+        invalid_thread_argument( int ev )
+        : base_type(ev, "boost::invalid_thread_argument")
+        {
+        }
+        invalid_thread_argument( int ev, const char * what_arg )
+        : base_type(ev, what_arg)
+        {
+        }
+        invalid_thread_argument( int ev, const std::string & what_arg )
+        : base_type(ev, what_arg)
+        {
+        }
+
+    };
+
+    class BOOST_SYMBOL_VISIBLE thread_permission_error:
+        public thread_exception
+    {
+          typedef thread_exception base_type;
+    public:
+          thread_permission_error()
+          : base_type(system::errc::permission_denied, "boost::thread_permission_error")
+          {}
+
+          thread_permission_error( int ev )
+          : base_type(ev, "boost::thread_permission_error")
+          {
+          }
+          thread_permission_error( int ev, const char * what_arg )
+          : base_type(ev, what_arg)
+          {
+          }
+          thread_permission_error( int ev, const std::string & what_arg )
+          : base_type(ev, what_arg)
+          {
+          }
+
+    };

 } // namespace boost

 #include <boost/config/abi_suffix.hpp>

-#endif // BOOST_THREAD_CONFIG_PDM070801_H
-
-// Change log:
-//    3 Jan 03  WEKEMPF Modified for DLL implementation.
-
+#endif
--- a/include/boost/thread/future.hpp
+++ b/include/boost/thread/future.hpp
--- a/include/boost/thread/locks.hpp
+++ b/include/boost/thread/locks.hpp
--- a/include/boost/thread/once.hpp
+++ b/include/boost/thread/once.hpp
@@ -3,7 +3,7 @@

 //  once.hpp
 //
-//  (C) Copyright 2006-7 Anthony Williams 
+//  (C) Copyright 2006-7 Anthony Williams
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -22,6 +22,7 @@

 namespace boost
 {
+  // template<class Callable, class ...Args> void call_once(once_flag& flag, Callable func, Args&&... args);
    inline void call_once(void (*func)(),once_flag& flag)
    {
        call_once(flag,func);
--- a/include/boost/thread/pthread/condition_variable.hpp
+++ b/include/boost/thread/pthread/condition_variable.hpp
@@ -3,53 +3,123 @@
 // 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)
-// (C) Copyright 2007-8 Anthony Williams
+// (C) Copyright 2007-10 Anthony Williams
+// (C) Copyright 2011 Vicente J. Botet Escriba

-#include "timespec.hpp"
-#include "pthread_mutex_scoped_lock.hpp"
-#include "thread_data.hpp"
-#include "condition_variable_fwd.hpp"
+#include <boost/thread/pthread/timespec.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#include <boost/thread/pthread/thread_data.hpp>
+#include <boost/thread/pthread/condition_variable_fwd.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
-    inline void condition_variable::wait(unique_lock<mutex>& m)
+    namespace this_thread
    {
-        detail::interruption_checker check_for_interruption(&cond);
-        BOOST_VERIFY(!pthread_cond_wait(&cond,m.mutex()->native_handle()));
+        void BOOST_THREAD_DECL interruption_point();
    }

-    inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
+    namespace thread_cv_detail
    {
-        detail::interruption_checker check_for_interruption(&cond);
-        struct timespec const timeout=detail::get_timespec(wait_until);
-        int const cond_res=pthread_cond_timedwait(&cond,m.mutex()->native_handle(),&timeout);
+        template<typename MutexType>
+        struct lock_on_exit
+        {
+            MutexType* m;
+
+            lock_on_exit():
+                m(0)
+            {}
+
+            void activate(MutexType& m_)
+            {
+                m_.unlock();
+                m=&m_;
+            }
+            ~lock_on_exit()
+            {
+                if(m)
+                {
+                    m->lock();
+                }
+           }
+        };
+    }
+
+    inline void condition_variable::wait(unique_lock<mutex>& m)
+    {
+        int res=0;
+        {
+            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
+            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+            guard.activate(m);
+            do {
+              res = pthread_cond_wait(&cond,&internal_mutex);
+            } while (res == EINTR);
+        }
+        this_thread::interruption_point();
+        if(res)
+        {
+            boost::throw_exception(condition_error(res, "boost:: condition_variable constructor failed in pthread_cond_wait"));
+        }
+    }
+
+    inline bool condition_variable::do_timed_wait(
+                unique_lock<mutex>& m,
+                struct timespec const &timeout)
+    {
+        if (!m.owns_lock())
+            boost::throw_exception(condition_error(EPERM, "condition_variable do_timed_wait: mutex not locked"));
+
+        thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
+        int cond_res;
+        {
+            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+            guard.activate(m);
+            cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+        }
+        this_thread::interruption_point();
        if(cond_res==ETIMEDOUT)
        {
            return false;
        }
-        BOOST_ASSERT(!cond_res);
+        if(cond_res)
+        {
+            boost::throw_exception(condition_error(cond_res, "condition_variable failed in pthread_cond_timedwait"));
+        }
        return true;
    }

-    inline void condition_variable::notify_one()
+    inline void condition_variable::notify_one() BOOST_NOEXCEPT
    {
+        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
        BOOST_VERIFY(!pthread_cond_signal(&cond));
    }
-        
-    inline void condition_variable::notify_all()
+
+    inline void condition_variable::notify_all() BOOST_NOEXCEPT
    {
+        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
        BOOST_VERIFY(!pthread_cond_broadcast(&cond));
    }
-    
+
    class condition_variable_any
    {
        pthread_mutex_t internal_mutex;
        pthread_cond_t cond;

-        condition_variable_any(condition_variable&);
-        condition_variable_any& operator=(condition_variable&);
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+    public:
+        condition_variable_any(condition_variable_any const&) = delete;
+        condition_variable_any& operator=(condition_variable_any const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+    private:
+        condition_variable_any(condition_variable_any&);
+        condition_variable_any& operator=(condition_variable_any&);
+#endif // BOOST_NO_DELETED_FUNCTIONS

    public:
        condition_variable_any()
@@ -57,13 +127,13 @@ namespace boost
            int const res=pthread_mutex_init(&internal_mutex,NULL);
            if(res)
            {
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res, "condition_variable_any failed in pthread_mutex_init"));
            }
            int const res2=pthread_cond_init(&cond,NULL);
            if(res2)
            {
                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res, "condition_variable_any failed in pthread_cond_init"));
            }
        }
        ~condition_variable_any()
@@ -71,23 +141,21 @@ namespace boost
            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
            BOOST_VERIFY(!pthread_cond_destroy(&cond));
        }
-        
+
        template<typename lock_type>
        void wait(lock_type& m)
        {
            int res=0;
            {
-                detail::interruption_checker check_for_interruption(&cond);
-                {
-                    boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-                    m.unlock();
-                    res=pthread_cond_wait(&cond,&internal_mutex);
-                }
-                m.lock();
+                thread_cv_detail::lock_on_exit<lock_type> guard;
+                detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+                guard.activate(m);
+                res=pthread_cond_wait(&cond,&internal_mutex);
            }
+            this_thread::interruption_point();
            if(res)
            {
-                throw condition_error();
+                boost::throw_exception(condition_error(res, "condition_variable_any failed in pthread_cond_wait"));
            }
        }

@@ -96,30 +164,23 @@ namespace boost
        {
            while(!pred()) wait(m);
        }
-        
+
        template<typename lock_type>
        bool timed_wait(lock_type& m,boost::system_time const& wait_until)
        {
            struct timespec const timeout=detail::get_timespec(wait_until);
-            int res=0;
-            {
-                detail::interruption_checker check_for_interruption(&cond);
-                {
-                    boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-                    m.unlock();
-                    res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
-                }
-                m.lock();
-            }
-            if(res==ETIMEDOUT)
-            {
-                return false;
-            }
-            if(res)
-            {
-                throw condition_error();
-            }
-            return true;
+            return do_timed_wait(m, timeout);
+        }
+        template<typename lock_type>
+        bool timed_wait(lock_type& m,xtime const& wait_until)
+        {
+            return timed_wait(m,system_time(wait_until));
+        }
+
+        template<typename lock_type,typename duration_type>
+        bool timed_wait(lock_type& m,duration_type const& wait_duration)
+        {
+            return timed_wait(m,get_system_time()+wait_duration);
        }

        template<typename lock_type,typename predicate_type>
@@ -145,17 +206,134 @@ namespace boost
            return timed_wait(m,get_system_time()+wait_duration,pred);
        }

-        void notify_one()
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class lock_type,class Duration>
+        cv_status
+        wait_until(
+                lock_type& lock,
+                const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
+          wait_until(lock,
+                        nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
+          return system_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;
+          system_clock::time_point     s_now = system_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 Clock, class Duration, class Predicate>
+        bool
+        wait_until(
+                lock_type& 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 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(
+                lock_type& lock,
+                const chrono::duration<Rep, Period>& d,
+                Predicate pred)
+        {
+          while (!pred())
+          {
+              if (wait_for(lock, d) == cv_status::timeout)
+                  return pred();
+          }
+          return true;
+        }
+
+        template <class lock_type>
+        inline void 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;
+            seconds s = duration_cast<seconds>(d);
+            ts.tv_sec = static_cast<long>(s.count());
+            ts.tv_nsec = static_cast<long>((d - s).count());
+            do_timed_wait(lk, ts);
+        }
+#endif
+
+        void notify_one() BOOST_NOEXCEPT
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
            BOOST_VERIFY(!pthread_cond_signal(&cond));
        }
-        
-        void notify_all()
+
+        void notify_all() BOOST_NOEXCEPT
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
            BOOST_VERIFY(!pthread_cond_broadcast(&cond));
        }
+    private: // used by boost::thread::try_join_until
+
+        template <class lock_type>
+        inline bool do_timed_wait(
+          lock_type& m,
+          struct timespec const &timeout)
+        {
+          int res=0;
+          {
+              thread_cv_detail::lock_on_exit<lock_type> guard;
+              detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+              guard.activate(m);
+              res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+          }
+          this_thread::interruption_point();
+          if(res==ETIMEDOUT)
+          {
+              return false;
+          }
+          if(res)
+          {
+              boost::throw_exception(condition_error(res, "condition_variable_any failed in pthread_cond_timedwait"));
+          }
+          return true;
+        }
+
+
    };

 }
--- a/include/boost/thread/pthread/condition_variable_fwd.hpp
+++ b/include/boost/thread/pthread/condition_variable_fwd.hpp
@@ -4,38 +4,65 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // (C) Copyright 2007-8 Anthony Williams
+// (C) Copyright 2011 Vicente J. Botet Escriba

 #include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>
 #include <pthread.h>
+#include <boost/thread/cv_status.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/locks.hpp>
 #include <boost/thread/thread_time.hpp>
 #include <boost/thread/xtime.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
+
    class condition_variable
    {
    private:
+        pthread_mutex_t internal_mutex;
        pthread_cond_t cond;
-        
-        condition_variable(condition_variable&);
-        condition_variable& operator=(condition_variable&);
+
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+    public:
+        condition_variable(condition_variable const&) = delete;
+        condition_variable& operator=(condition_variable const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+    private:
+      condition_variable(condition_variable const&);
+      condition_variable& operator=(condition_variable const&);
+#endif // BOOST_NO_DELETED_FUNCTIONS

    public:
        condition_variable()
        {
-            int const res=pthread_cond_init(&cond,NULL);
+            int const res=pthread_mutex_init(&internal_mutex,NULL);
            if(res)
            {
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res, "boost:: condition_variable constructor failed in pthread_mutex_init"));
+            }
+            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 constructor failed in pthread_cond_init"));
            }
        }
        ~condition_variable()
        {
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+            int ret;
+            do {
+              ret = pthread_cond_destroy(&cond);
+            } while (ret == EINTR);
+            BOOST_VERIFY(!ret);
        }

        void wait(unique_lock<mutex>& m);
@@ -46,10 +73,32 @@ namespace boost
            while(!pred()) wait(m);
        }

-        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until);
+        inline bool timed_wait(
+            unique_lock<mutex>& m,
+            boost::system_time const& wait_until)
+        {
+            struct timespec const timeout=detail::get_timespec(wait_until);
+            return do_timed_wait(m, timeout);
+        }
+        bool timed_wait(
+            unique_lock<mutex>& m,
+            xtime const& wait_until)
+        {
+            return timed_wait(m,system_time(wait_until));
+        }
+
+        template<typename duration_type>
+        bool timed_wait(
+            unique_lock<mutex>& m,
+            duration_type const& wait_duration)
+        {
+            return timed_wait(m,get_system_time()+wait_duration);
+        }

        template<typename predicate_type>
-        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until,predicate_type pred)
+        bool timed_wait(
+            unique_lock<mutex>& m,
+            boost::system_time const& wait_until,predicate_type pred)
        {
            while (!pred())
            {
@@ -60,25 +109,127 @@ namespace boost
        }

        template<typename predicate_type>
-        bool timed_wait(unique_lock<mutex>& m,xtime const& wait_until,predicate_type pred)
+        bool timed_wait(
+            unique_lock<mutex>& m,
+            xtime const& wait_until,predicate_type pred)
        {
            return timed_wait(m,system_time(wait_until),pred);
        }

        template<typename duration_type,typename predicate_type>
-        bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred)
+        bool timed_wait(
+            unique_lock<mutex>& m,
+            duration_type const& wait_duration,predicate_type pred)
        {
            return timed_wait(m,get_system_time()+wait_duration,pred);
        }

+#ifdef BOOST_THREAD_USES_CHRONO
+
+        template <class Duration>
+        cv_status
+        wait_until(
+                unique_lock<mutex>& lock,
+                const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
+          wait_until(lock,
+                        nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
+          return system_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;
+          system_clock::time_point     s_now = system_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 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>
+        cv_status
+        wait_for(
+                unique_lock<mutex>& 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 Rep, class Period, class Predicate>
+        bool
+        wait_for(
+                unique_lock<mutex>& lock,
+                const chrono::duration<Rep, Period>& d,
+                Predicate pred)
+        {
+          while (!pred())
+          {
+              if (wait_for(lock, d) == cv_status::timeout)
+                  return pred();
+          }
+          return true;
+        }
+#endif
+
+#define BOOST_THREAD_DEFINES_CONDITION_VARIABLE_NATIVE_HANDLE
        typedef pthread_cond_t* native_handle_type;
        native_handle_type native_handle()
        {
            return &cond;
        }

-        void notify_one();
-        void notify_all();
+        void notify_one() BOOST_NOEXCEPT;
+        void notify_all() BOOST_NOEXCEPT;
+
+#ifdef BOOST_THREAD_USES_CHRONO
+        inline void 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;
+            seconds s = duration_cast<seconds>(d);
+            ts.tv_sec = static_cast<long>(s.count());
+            ts.tv_nsec = static_cast<long>((d - s).count());
+            do_timed_wait(lk, ts);
+        }
+#endif
+        //private: // used by boost::thread::try_join_until
+
+        inline bool do_timed_wait(
+            unique_lock<mutex>& lock,
+            struct timespec const &timeout);
    };
 }

--- a/include/boost/thread/pthread/mutex.hpp
+++ b/include/boost/thread/pthread/mutex.hpp
@@ -1,22 +1,29 @@
 #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
 // 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 <pthread.h>
 #include <boost/utility.hpp>
+#include <boost/throw_exception.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <boost/thread/locks.hpp>
 #include <boost/thread/thread_time.hpp>
+#include <boost/thread/xtime.hpp>
 #include <boost/assert.hpp>
 #include <errno.h>
-#include "timespec.hpp"
-#include "pthread_mutex_scoped_lock.hpp"
+#include <boost/thread/pthread/timespec.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #ifdef _POSIX_TIMEOUTS
-#if _POSIX_TIMEOUTS >= 0
+#if _POSIX_TIMEOUTS >= 0 && _POSIX_C_SOURCE>=200112L
 #define BOOST_PTHREAD_HAS_TIMEDLOCK
 #endif
 #endif
@@ -25,9 +32,17 @@

 namespace boost
 {
-    class mutex:
-        boost::noncopyable
+    class mutex
    {
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+    public:
+      mutex(mutex const&) = delete;
+      mutex& operator=(mutex const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+  private:
+      mutex(mutex const&);
+      mutex& operator=(mutex const&);
+#endif // BOOST_NO_DELETED_FUNCTIONS
    private:
        pthread_mutex_t m;
    public:
@@ -36,31 +51,61 @@ namespace boost
            int const res=pthread_mutex_init(&m,NULL);
            if(res)
            {
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res, "boost:: mutex constructor failed in pthread_mutex_init"));
            }
        }
        ~mutex()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+            int ret;
+            do
+            {
+                ret = pthread_mutex_destroy(&m);
+            } while (ret == EINTR);
        }
-        
+
        void lock()
        {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            int res;
+            do
+            {
+                res = pthread_mutex_lock(&m);
+            } while (res == EINTR);
+            if (res)
+            {
+                boost::throw_exception(lock_error(res,"boost: mutex lock failed in pthread_mutex_lock"));
+            }
        }

        void unlock()
        {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            int ret;
+            do
+            {
+                ret = pthread_mutex_unlock(&m);
+            } while (ret == EINTR);
+            BOOST_VERIFY(!ret);
        }
-        
+
        bool try_lock()
        {
-            int const res=pthread_mutex_trylock(&m);
-            BOOST_ASSERT(!res || res==EBUSY);
+            int res;
+            do
+            {
+                res = pthread_mutex_trylock(&m);
+            } while (res == EINTR);
+            if(res && (res!=EBUSY))
+            {
+                // The following throw_exception has been replaced by an assertion and just return false,
+                // as this is an internal error and the user can do nothing with the exception.
+                //boost::throw_exception(lock_error(res,"boost: mutex try_lock failed in pthread_mutex_trylock"));
+                BOOST_ASSERT_MSG(false ,"boost: mutex try_lock failed in pthread_mutex_trylock");
+                return false;
+            }
+
            return !res;
        }

+#define BOOST_THREAD_DEFINES_MUTEX_NATIVE_HANDLE
        typedef pthread_mutex_t* native_handle_type;
        native_handle_type native_handle()
        {
@@ -73,9 +118,18 @@ namespace boost

    typedef mutex try_mutex;

-    class timed_mutex:
-        boost::noncopyable
+    class timed_mutex
    {
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+    public:
+      timed_mutex(timed_mutex const&) = delete;
+      timed_mutex& operator=(timed_mutex const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+    private:
+      timed_mutex(timed_mutex const&);
+      timed_mutex& operator=(timed_mutex const&);
+    public:
+#endif // BOOST_NO_DELETED_FUNCTIONS
    private:
        pthread_mutex_t m;
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
@@ -88,14 +142,14 @@ namespace boost
            int const res=pthread_mutex_init(&m,NULL);
            if(res)
            {
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res, "boost:: timed_mutex constructor failed in pthread_mutex_init"));
            }
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
            int const res2=pthread_cond_init(&cond,NULL);
            if(res2)
            {
                BOOST_VERIFY(!pthread_mutex_destroy(&m));
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res2, "boost:: timed_mutex constructor failed in pthread_cond_init"));
            }
            is_locked=false;
 #endif
@@ -113,6 +167,10 @@ namespace boost
        {
            return timed_lock(get_system_time()+relative_time);
        }
+        bool timed_lock(boost::xtime const & absolute_time)
+        {
+            return timed_lock(system_time(absolute_time));
+        }

 #ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
        void lock()
@@ -124,26 +182,23 @@ namespace boost
        {
            BOOST_VERIFY(!pthread_mutex_unlock(&m));
        }
-        
+
        bool try_lock()
        {
            int const res=pthread_mutex_trylock(&m);
            BOOST_ASSERT(!res || res==EBUSY);
            return !res;
        }
-        bool timed_lock(system_time const & abs_time)
-        {
-            struct timespec const timeout=detail::get_timespec(abs_time);
-            int const res=pthread_mutex_timedlock(&m,&timeout);
-            BOOST_ASSERT(!res || res==ETIMEDOUT);
-            return !res;
-        }

-        typedef pthread_mutex_t* native_handle_type;
-        native_handle_type native_handle()
+
+    private:
+        bool do_try_lock_until(struct timespec const &timeout)
        {
-            return &m;
+          int const res=pthread_mutex_timedlock(&m,&timeout);
+          BOOST_ASSERT(!res || res==ETIMEDOUT);
+          return !res;
        }
+    public:

 #else
        void lock()
@@ -162,7 +217,7 @@ namespace boost
            is_locked=false;
            BOOST_VERIFY(!pthread_cond_signal(&cond));
        }
-        
+
        bool try_lock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
@@ -174,9 +229,9 @@ namespace boost
            return true;
        }

-        bool timed_lock(system_time const & abs_time)
+    private:
+        bool do_try_lock_until(struct timespec const &timeout)
        {
-            struct timespec const timeout=detail::get_timespec(abs_time);
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            while(is_locked)
            {
@@ -190,8 +245,55 @@ namespace boost
            is_locked=true;
            return true;
        }
+    public:
 #endif

+        bool timed_lock(system_time const & abs_time)
+        {
+            struct timespec const ts=detail::get_timespec(abs_time);
+            return do_try_lock_until(ts);
+        }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
+          typename Clock::time_point  c_now = Clock::now();
+          return try_lock_until(s_now + ceil<nanoseconds>(t - c_now));
+        }
+        template <class Duration>
+        bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
+          return try_lock_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
+        }
+        bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
+        {
+          using namespace chrono;
+          nanoseconds d = tp.time_since_epoch();
+          timespec ts;
+          seconds s = duration_cast<seconds>(d);
+          ts.tv_sec = static_cast<long>(s.count());
+          ts.tv_nsec = static_cast<long>((d - s).count());
+          return do_try_lock_until(ts);
+        }
+#endif
+
+#define BOOST_THREAD_DEFINES_TIMED_MUTEX_NATIVE_HANDLE
+        typedef pthread_mutex_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &m;
+        }
+
        typedef unique_lock<timed_mutex> scoped_timed_lock;
        typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
        typedef scoped_timed_lock scoped_lock;
--- a/include/boost/thread/pthread/once.hpp
+++ b/include/boost/thread/pthread/once.hpp
@@ -3,7 +3,7 @@

 //  once.hpp
 //
-//  (C) Copyright 2007-8 Anthony Williams 
+//  (C) Copyright 2007-8 Anthony Williams
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -13,7 +13,6 @@

 #include <pthread.h>
 #include <boost/assert.hpp>
-#include "pthread_mutex_scoped_lock.hpp"
 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 #include <boost/cstdint.hpp>

@@ -22,11 +21,39 @@
 namespace boost
 {

+#if BOOST_THREAD_VERSION==3
+
+  struct once_flag
+  {
+      BOOST_CONSTEXPR once_flag() BOOST_NOEXCEPT
+        : epoch(0)
+      {}
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+      once_flag(const once_flag&) = delete;
+      once_flag& operator=(const once_flag&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+  private:
+      once_flag(const once_flag&);
+      once_flag& operator=(const once_flag&);
+  public:
+#endif // BOOST_NO_DELETED_FUNCTIONS
+  private:
+      boost::uintmax_t epoch;
+
+  };
+
+#else // BOOST_THREAD_VERSION==3
+
    struct once_flag
    {
        boost::uintmax_t epoch;
    };

+#define BOOST_ONCE_INITIAL_FLAG_VALUE 0
+#define BOOST_ONCE_INIT {BOOST_ONCE_INITIAL_FLAG_VALUE}
+
+#endif // BOOST_THREAD_VERSION==3
+
    namespace detail
    {
        BOOST_THREAD_DECL boost::uintmax_t& get_once_per_thread_epoch();
@@ -34,10 +61,6 @@ namespace boost
        BOOST_THREAD_DECL extern pthread_mutex_t once_epoch_mutex;
        BOOST_THREAD_DECL extern pthread_cond_t once_epoch_cv;
    }
-    
-#define BOOST_ONCE_INITIAL_FLAG_VALUE 0
-#define BOOST_ONCE_INIT {BOOST_ONCE_INITIAL_FLAG_VALUE}
-

    // Based on Mike Burrows fast_pthread_once algorithm as described in
    // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html
@@ -48,7 +71,7 @@ namespace boost
        static boost::uintmax_t const being_initialized=uninitialized_flag+1;
        boost::uintmax_t const epoch=flag.epoch;
        boost::uintmax_t& this_thread_epoch=detail::get_once_per_thread_epoch();
-        
+
        if(epoch<this_thread_epoch)
        {
            pthread::pthread_mutex_scoped_lock lk(&detail::once_epoch_mutex);
@@ -58,10 +81,13 @@ namespace boost
                if(flag.epoch==uninitialized_flag)
                {
                    flag.epoch=being_initialized;
+#ifndef BOOST_NO_EXCEPTIONS
                    try
                    {
+#endif
                        pthread::pthread_mutex_scoped_unlock relocker(&detail::once_epoch_mutex);
                        f();
+#ifndef BOOST_NO_EXCEPTIONS
                    }
                    catch(...)
                    {
@@ -69,6 +95,7 @@ namespace boost
                        BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
                        throw;
                    }
+#endif
                    flag.epoch=--detail::once_global_epoch;
                    BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
                }
--- a/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp
+++ b/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp
@@ -18,15 +18,25 @@ namespace boost
        class pthread_mutex_scoped_lock
        {
            pthread_mutex_t* m;
+            bool locked;
        public:
            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
-                m(m_)
+                m(m_),locked(true)
            {
                BOOST_VERIFY(!pthread_mutex_lock(m));
            }
-            ~pthread_mutex_scoped_lock()
+            void unlock()
            {
                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                locked=false;
+            }
+            
+            ~pthread_mutex_scoped_lock()
+            {
+                if(locked)
+                {
+                    unlock();
+                }
            }
            
        };
--- a/include/boost/thread/pthread/recursive_mutex.hpp
+++ b/include/boost/thread/pthread/recursive_mutex.hpp
@@ -7,6 +7,7 @@

 #include <pthread.h>
 #include <boost/utility.hpp>
+#include <boost/throw_exception.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <boost/thread/locks.hpp>
 #include <boost/thread/thread_time.hpp>
@@ -16,8 +17,12 @@
 #endif
 #include <boost/date_time/posix_time/conversion.hpp>
 #include <errno.h>
-#include "timespec.hpp"
-#include "pthread_mutex_scoped_lock.hpp"
+#include <boost/thread/pthread/timespec.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #ifdef _POSIX_TIMEOUTS
 #if _POSIX_TIMEOUTS >= 0
@@ -25,138 +30,83 @@
 #endif
 #endif

+#if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE) && defined(BOOST_PTHREAD_HAS_TIMEDLOCK)
+#define BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+#endif
+
 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
-    class recursive_mutex:
-        boost::noncopyable
+    class recursive_mutex
    {
-    private:
-        pthread_mutex_t m;
+#ifndef BOOST_NO_DELETED_FUNCTIONS
    public:
-        recursive_mutex()
-        {
-            pthread_mutexattr_t attr;
-            
-            int const init_attr_res=pthread_mutexattr_init(&attr);
-            if(init_attr_res)
-            {
-                throw thread_resource_error();
-            }
-            int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
-            if(set_attr_res)
-            {
-                throw thread_resource_error();
-            }
-            
-            int const res=pthread_mutex_init(&m,&attr);
-            if(res)
-            {
-                throw thread_resource_error();
-            }
-            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
-        }
-        ~recursive_mutex()
-        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
-        }
-        
-        void lock()
-        {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
-        }
-
-        void unlock()
-        {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
-        }
-        
-        bool try_lock()
-        {
-            int const res=pthread_mutex_trylock(&m);
-            BOOST_ASSERT(!res || res==EBUSY);
-            return !res;
-        }
-
-        typedef pthread_mutex_t* native_handle_type;
-        native_handle_type native_handle()
-        {
-            return &m;
-        }
-
-        typedef unique_lock<recursive_mutex> scoped_lock;
-        typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
-    };
-
-    typedef recursive_mutex recursive_try_mutex;
-
-    class recursive_timed_mutex:
-        boost::noncopyable
-    {
+      recursive_mutex(recursive_mutex const&) = delete;
+      recursive_mutex& operator=(recursive_mutex const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+  private:
+      recursive_mutex(recursive_mutex const&);
+      recursive_mutex& operator=(recursive_mutex const&);
+#endif // BOOST_NO_DELETED_FUNCTIONS
    private:
        pthread_mutex_t m;
-#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
        pthread_cond_t cond;
        bool is_locked;
        pthread_t owner;
        unsigned count;
 #endif
    public:
-        recursive_timed_mutex()
+        recursive_mutex()
        {
-#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
+#ifdef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
            pthread_mutexattr_t attr;
-            
+
            int const init_attr_res=pthread_mutexattr_init(&attr);
            if(init_attr_res)
            {
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(init_attr_res, "boost:: recursive_mutex constructor failed in pthread_mutexattr_init"));
            }
            int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
            if(set_attr_res)
            {
-                throw thread_resource_error();
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+                boost::throw_exception(thread_resource_error(set_attr_res, "boost:: recursive_mutex constructor failed in pthread_mutexattr_settype"));
            }
-            
+
            int const res=pthread_mutex_init(&m,&attr);
            if(res)
            {
                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res, "boost:: recursive_mutex constructor failed in pthread_mutex_init"));
            }
            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
 #else
            int const res=pthread_mutex_init(&m,NULL);
            if(res)
            {
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res, "boost:: recursive_mutex constructor failed in pthread_mutex_init"));
            }
            int const res2=pthread_cond_init(&cond,NULL);
            if(res2)
            {
                BOOST_VERIFY(!pthread_mutex_destroy(&m));
-                throw thread_resource_error();
+                boost::throw_exception(thread_resource_error(res2, "boost:: recursive_mutex constructor failed in pthread_cond_init"));
            }
            is_locked=false;
            count=0;
 #endif
        }
-        ~recursive_timed_mutex()
+        ~recursive_mutex()
        {
            BOOST_VERIFY(!pthread_mutex_destroy(&m));
-#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
            BOOST_VERIFY(!pthread_cond_destroy(&cond));
 #endif
        }

-        template<typename TimeDuration>
-        bool timed_lock(TimeDuration const & relative_time)
-        {
-            return timed_lock(get_system_time()+relative_time);
-        }
-
-#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
+#ifdef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
        void lock()
        {
            BOOST_VERIFY(!pthread_mutex_lock(&m));
@@ -166,21 +116,14 @@ namespace boost
        {
            BOOST_VERIFY(!pthread_mutex_unlock(&m));
        }
-        
+
        bool try_lock()
        {
            int const res=pthread_mutex_trylock(&m);
            BOOST_ASSERT(!res || res==EBUSY);
            return !res;
        }
-        bool timed_lock(system_time const & abs_time)
-        {
-            struct timespec const timeout=detail::get_timespec(abs_time);
-            int const res=pthread_mutex_timedlock(&m,&timeout);
-            BOOST_ASSERT(!res || res==EBUSY);
-            return !res;
-        }
-
+#define BOOST_THREAD_DEFINES_RECURSIVE_MUTEX_NATIVE_HANDLE
        typedef pthread_mutex_t* native_handle_type;
        native_handle_type native_handle()
        {
@@ -196,7 +139,7 @@ namespace boost
                ++count;
                return;
            }
-            
+
            while(is_locked)
            {
                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
@@ -215,7 +158,7 @@ namespace boost
            }
            BOOST_VERIFY(!pthread_cond_signal(&cond));
        }
-        
+
        bool try_lock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
@@ -229,9 +172,159 @@ namespace boost
            return true;
        }

-        bool timed_lock(system_time const & abs_time)
+#endif
+
+        typedef unique_lock<recursive_mutex> scoped_lock;
+        typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
+    };
+
+    typedef recursive_mutex recursive_try_mutex;
+
+    class recursive_timed_mutex
+    {
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+    public:
+      recursive_timed_mutex(recursive_timed_mutex const&) = delete;
+      recursive_timed_mutex& operator=(recursive_timed_mutex const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+    private:
+      recursive_timed_mutex(recursive_timed_mutex const&);
+      recursive_timed_mutex& operator=(recursive_timed_mutex const&);
+#endif // BOOST_NO_DELETED_FUNCTIONS
+    private:
+        pthread_mutex_t m;
+#ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+        pthread_cond_t cond;
+        bool is_locked;
+        pthread_t owner;
+        unsigned count;
+#endif
+    public:
+        recursive_timed_mutex()
+        {
+#ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+            pthread_mutexattr_t attr;
+
+            int const init_attr_res=pthread_mutexattr_init(&attr);
+            if(init_attr_res)
+            {
+                boost::throw_exception(thread_resource_error(init_attr_res, "boost:: recursive_timed_mutex constructor failed in pthread_mutexattr_init"));
+            }
+            int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
+            if(set_attr_res)
+            {
+                boost::throw_exception(thread_resource_error(set_attr_res, "boost:: recursive_timed_mutex constructor failed in pthread_mutexattr_settype"));
+            }
+
+            int const res=pthread_mutex_init(&m,&attr);
+            if(res)
+            {
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+                boost::throw_exception(thread_resource_error(res, "boost:: recursive_timed_mutex constructor failed in pthread_mutex_init"));
+            }
+            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+#else
+            int const res=pthread_mutex_init(&m,NULL);
+            if(res)
+            {
+                boost::throw_exception(thread_resource_error(res, "boost:: recursive_timed_mutex constructor failed in pthread_mutex_init"));
+            }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                boost::throw_exception(thread_resource_error(res2, "boost:: recursive_timed_mutex constructor failed in pthread_cond_init"));
+            }
+            is_locked=false;
+            count=0;
+#endif
+        }
+        ~recursive_timed_mutex()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+#ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+#endif
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time)
+        {
+            return timed_lock(get_system_time()+relative_time);
+        }
+
+#ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+        void lock()
+        {
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
+        }
+
+        void unlock()
+        {
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+        }
+
+        bool try_lock()
+        {
+            int const res=pthread_mutex_trylock(&m);
+            BOOST_ASSERT(!res || res==EBUSY);
+            return !res;
+        }
+    private:
+        bool do_try_lock_until(struct timespec const &timeout)
+        {
+            int const res=pthread_mutex_timedlock(&m,&timeout);
+            BOOST_ASSERT(!res || res==ETIMEDOUT);
+            return !res;
+        }
+
+    public:
+
+#else
+        void lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && pthread_equal(owner,pthread_self()))
+            {
+                ++count;
+                return;
+            }
+
+            while(is_locked)
+            {
+                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+        }
+
+        void unlock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(!--count)
+            {
+                is_locked=false;
+            }
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
+        }
+
+        bool try_lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && !pthread_equal(owner,pthread_self()))
+            {
+                return false;
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+            return true;
+        }
+
+    private:
+        bool do_try_lock_until(struct timespec const &timeout)
        {
-            struct timespec const timeout=detail::get_timespec(abs_time);
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            if(is_locked && pthread_equal(owner,pthread_self()))
            {
@@ -252,8 +345,56 @@ namespace boost
            owner=pthread_self();
            return true;
        }
+    public:
+
 #endif

+        bool timed_lock(system_time const & abs_time)
+        {
+            struct timespec const ts=detail::get_timespec(abs_time);
+            return do_try_lock_until(ts);
+        }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
+          typename Clock::time_point  c_now = Clock::now();
+          return try_lock_until(s_now + ceil<nanoseconds>(t - c_now));
+        }
+        template <class Duration>
+        bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
+          return try_lock_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
+        }
+        bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
+        {
+          using namespace chrono;
+          nanoseconds d = tp.time_since_epoch();
+          timespec ts;
+          seconds s = duration_cast<seconds>(d);
+          ts.tv_sec = static_cast<long>(s.count());
+          ts.tv_nsec = static_cast<long>((d - s).count());
+          return do_try_lock_until(ts);
+        }
+#endif
+
+#define BOOST_THREAD_DEFINES_RECURSIVE_TIMED_MUTEX_NATIVE_HANDLE
+        typedef pthread_mutex_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &m;
+        }
+
        typedef unique_lock<recursive_timed_mutex> scoped_timed_lock;
        typedef detail::try_lock_wrapper<recursive_timed_mutex> scoped_try_lock;
        typedef scoped_timed_lock scoped_lock;
--- a/include/boost/thread/pthread/shared_mutex.hpp
+++ b/include/boost/thread/pthread/shared_mutex.hpp
@@ -2,6 +2,7 @@
 #define BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP

 //  (C) Copyright 2006-8 Anthony Williams
+//  (C) Copyright 2012 Vicente J. Botet Escriba
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -10,8 +11,12 @@
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
 #include <boost/thread/condition_variable.hpp>
+#include <boost/thread/detail/thread_interruption.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -27,7 +32,7 @@ namespace boost
            bool upgrade;
            bool exclusive_waiting_blocked;
        };
-        
+


        state_data state;
@@ -41,9 +46,19 @@ namespace boost
            exclusive_cond.notify_one();
            shared_cond.notify_all();
        }
-        

+
+#ifndef BOOST_NO_DELETED_FUNCTIONS
    public:
+        shared_mutex(shared_mutex const&) = delete;
+        shared_mutex& operator=(shared_mutex const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+    private:
+        shared_mutex(shared_mutex const&);
+        shared_mutex& operator=(shared_mutex const&);
+#endif // BOOST_NO_DELETED_FUNCTIONS
+    public:
+
        shared_mutex()
        {
            state_data state_={0,0,0,0};
@@ -57,19 +72,19 @@ namespace boost
        void lock_shared()
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lock(state_change);
-                
+            boost::mutex::scoped_lock lk(state_change);
+
            while(state.exclusive || state.exclusive_waiting_blocked)
            {
-                shared_cond.wait(lock);
+                shared_cond.wait(lk);
            }
            ++state.shared_count;
        }

        bool try_lock_shared()
        {
-            boost::mutex::scoped_lock lock(state_change);
-                
+            boost::mutex::scoped_lock lk(state_change);
+
            if(state.exclusive || state.exclusive_waiting_blocked)
            {
                return false;
@@ -84,11 +99,11 @@ namespace boost
        bool timed_lock_shared(system_time const& timeout)
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lock(state_change);
-                
+            boost::mutex::scoped_lock lk(state_change);
+
            while(state.exclusive || state.exclusive_waiting_blocked)
            {
-                if(!shared_cond.timed_wait(lock,timeout))
+                if(!shared_cond.timed_wait(lk,timeout))
                {
                    return false;
                }
@@ -102,12 +117,34 @@ namespace boost
        {
            return timed_lock_shared(get_system_time()+relative_time);
        }
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time)
+        {
+          boost::this_thread::disable_interruption do_not_disturb;
+          boost::mutex::scoped_lock lk(state_change);

+          while(state.exclusive || state.exclusive_waiting_blocked)
+          {
+              if(cv_status::timeout==shared_cond.wait_until(lk,abs_time))
+              {
+                  return false;
+              }
+          }
+          ++state.shared_count;
+          return true;
+        }
+#endif
        void unlock_shared()
        {
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            bool const last_reader=!--state.shared_count;
-                
+
            if(last_reader)
            {
                if(state.upgrade)
@@ -127,12 +164,12 @@ namespace boost
        void lock()
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lock(state_change);
-                
+            boost::mutex::scoped_lock lk(state_change);
+
            while(state.shared_count || state.exclusive)
            {
                state.exclusive_waiting_blocked=true;
-                exclusive_cond.wait(lock);
+                exclusive_cond.wait(lk);
            }
            state.exclusive=true;
        }
@@ -140,17 +177,17 @@ namespace boost
        bool timed_lock(system_time const& timeout)
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);

            while(state.shared_count || state.exclusive)
            {
                state.exclusive_waiting_blocked=true;
-                if(!exclusive_cond.timed_wait(lock,timeout))
+                if(!exclusive_cond.timed_wait(lk,timeout))
                {
                    if(state.shared_count || state.exclusive)
                    {
                        state.exclusive_waiting_blocked=false;
-                        exclusive_cond.notify_one();
+                        release_waiters();
                        return false;
                    }
                    break;
@@ -166,10 +203,41 @@ namespace boost
            return timed_lock(get_system_time()+relative_time);
        }

+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
+        {
+          boost::this_thread::disable_interruption do_not_disturb;
+          boost::mutex::scoped_lock lk(state_change);
+
+          while(state.shared_count || state.exclusive)
+          {
+              state.exclusive_waiting_blocked=true;
+              if(cv_status::timeout == exclusive_cond.wait_until(lk,abs_time))
+              {
+                  if(state.shared_count || state.exclusive)
+                  {
+                      state.exclusive_waiting_blocked=false;
+                      release_waiters();
+                      return false;
+                  }
+                  break;
+              }
+          }
+          state.exclusive=true;
+          return true;
+        }
+#endif
+
        bool try_lock()
        {
-            boost::mutex::scoped_lock lock(state_change);
-                
+            boost::mutex::scoped_lock lk(state_change);
+
            if(state.shared_count || state.exclusive)
            {
                return false;
@@ -179,12 +247,12 @@ namespace boost
                state.exclusive=true;
                return true;
            }
-                
+
        }

        void unlock()
        {
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            state.exclusive=false;
            state.exclusive_waiting_blocked=false;
            release_waiters();
@@ -193,10 +261,10 @@ namespace boost
        void lock_upgrade()
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
-                shared_cond.wait(lock);
+                shared_cond.wait(lk);
            }
            ++state.shared_count;
            state.upgrade=true;
@@ -205,10 +273,10 @@ namespace boost
        bool timed_lock_upgrade(system_time const& timeout)
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
-                if(!shared_cond.timed_wait(lock,timeout))
+                if(!shared_cond.timed_wait(lk,timeout))
                {
                    if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
                    {
@@ -225,12 +293,39 @@ namespace boost
        template<typename TimeDuration>
        bool timed_lock_upgrade(TimeDuration const & relative_time)
        {
-            return timed_lock(get_system_time()+relative_time);
+            return timed_lock_upgrade(get_system_time()+relative_time);
        }

+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time)
+        {
+          boost::this_thread::disable_interruption do_not_disturb;
+          boost::mutex::scoped_lock lk(state_change);
+          while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+          {
+              if(cv_status::timeout == shared_cond.wait_until(lk,abs_time))
+              {
+                  if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+                  {
+                      return false;
+                  }
+                  break;
+              }
+          }
+          ++state.shared_count;
+          state.upgrade=true;
+          return true;
+        }
+#endif
        bool try_lock_upgrade()
        {
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
                return false;
@@ -245,25 +340,28 @@ namespace boost

        void unlock_upgrade()
        {
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            state.upgrade=false;
            bool const last_reader=!--state.shared_count;
-                
+
            if(last_reader)
            {
                state.exclusive_waiting_blocked=false;
                release_waiters();
+            } else {
+              shared_cond.notify_all();
            }
        }

+        // Upgrade <-> Exclusive
        void unlock_upgrade_and_lock()
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            --state.shared_count;
            while(state.shared_count)
            {
-                upgrade_cond.wait(lock);
+                upgrade_cond.wait(lk);
            }
            state.upgrade=false;
            state.exclusive=true;
@@ -271,31 +369,86 @@ namespace boost

        void unlock_and_lock_upgrade()
        {
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            state.exclusive=false;
            state.upgrade=true;
            ++state.shared_count;
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }
-        
+
+        bool try_unlock_upgrade_and_lock()
+        {
+          boost::mutex::scoped_lock lk(state_change);
+          if(    !state.exclusive
+              && !state.exclusive_waiting_blocked
+              && state.upgrade
+              && state.shared_count==1)
+          {
+            state.shared_count=0;
+            state.exclusive=true;
+            state.upgrade=false;
+            return true;
+          }
+          return false;
+        }
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool
+        try_unlock_upgrade_and_lock_for(
+                                const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_unlock_upgrade_and_lock_until(
+                                 chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool
+        try_unlock_upgrade_and_lock_until(
+                          const chrono::time_point<Clock, Duration>& abs_time)
+        {
+          boost::this_thread::disable_interruption do_not_disturb;
+          boost::mutex::scoped_lock lk(state_change);
+          if (state.shared_count != 1)
+          {
+              while (true)
+              {
+                cv_status status = shared_cond.wait_until(lk,abs_time);
+                if (state.shared_count == 1)
+                  break;
+                if(status == cv_status::timeout)
+                  return false;
+              }
+          }
+          state.upgrade=false;
+          state.exclusive=true;
+          state.exclusive_waiting_blocked=false;
+          state.shared_count=0;
+          return true;
+        }
+#endif
+
+        // Shared <-> Exclusive
        void unlock_and_lock_shared()
        {
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            state.exclusive=false;
            ++state.shared_count;
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }
-        
+
+        // Shared <-> Upgrade
        void unlock_upgrade_and_lock_shared()
        {
-            boost::mutex::scoped_lock lock(state_change);
+            boost::mutex::scoped_lock lk(state_change);
            state.upgrade=false;
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }
+
    };
+
+    typedef shared_mutex upgrade_mutex;
 }

 #include <boost/config/abi_suffix.hpp>
--- a/include/boost/thread/pthread/thread_data.hpp
+++ b/include/boost/thread/pthread/thread_data.hpp
@@ -12,22 +12,78 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/optional.hpp>
 #include <pthread.h>
-#include "condition_variable_fwd.hpp"
-
+#include <boost/assert.hpp>
+#include <boost/thread/pthread/condition_variable_fwd.hpp>
+#include <map>
+#include <unistd.h>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#endif
 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
+    class thread_attributes {
+    public:
+        thread_attributes() {
+            int res = pthread_attr_init(&val_);
+            BOOST_VERIFY(!res && "pthread_attr_init failed");
+        }
+        ~thread_attributes() {
+          int res = pthread_attr_destroy(&val_);
+          BOOST_VERIFY(!res && "pthread_attr_destroy failed");
+        }
+        // stack
+        void set_stack_size(std::size_t size) {
+          if (size==0) return;
+          std::size_t page_size = getpagesize();
+#ifdef PTHREAD_STACK_MIN
+          if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
+#endif
+          size = ((size+page_size-1)/page_size)*page_size;
+          int res = pthread_attr_setstacksize(&val_, size);
+          BOOST_VERIFY(!res && "pthread_attr_setstacksize failed");
+        }
+
+        std::size_t get_stack_size() const {
+            std::size_t size;
+            int res = pthread_attr_getstacksize(&val_, &size);
+            BOOST_VERIFY(!res && "pthread_attr_getstacksize failed");
+            return size;
+        }
+
+        typedef pthread_attr_t native_handle_type;
+        native_handle_type* native_handle() {
+          return &val_;
+        }
+        const native_handle_type* native_handle() const {
+          return &val_;
+        }
+
+    private:
+        pthread_attr_t val_;
+    };
+
    class thread;
-    
+
    namespace detail
    {
+        struct tss_cleanup_function;
        struct thread_exit_callback_node;
-        struct tss_data_node;
+        struct tss_data_node
+        {
+            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
+            void* value;
+
+            tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
+                          void* value_):
+                func(func_),value(value_)
+            {}
+        };

        struct thread_data_base;
        typedef boost::shared_ptr<thread_data_base> thread_data_ptr;
-        
+
        struct BOOST_THREAD_DECL thread_data_base:
            enable_shared_from_this<thread_data_base>
        {
@@ -41,14 +97,15 @@ namespace boost
            bool join_started;
            bool joined;
            boost::detail::thread_exit_callback_node* thread_exit_callbacks;
-            boost::detail::tss_data_node* tss_data;
+            std::map<void const*,boost::detail::tss_data_node> tss_data;
            bool interrupt_enabled;
            bool interrupt_requested;
+            pthread_mutex_t* cond_mutex;
            pthread_cond_t* current_cond;

            thread_data_base():
                done(false),join_started(false),joined(false),
-                thread_exit_callbacks(0),tss_data(0),
+                thread_exit_callbacks(0),
                interrupt_enabled(true),
                interrupt_requested(false),
                current_cond(0)
@@ -65,6 +122,8 @@ namespace boost
        class interruption_checker
        {
            thread_data_base* const thread_info;
+            pthread_mutex_t* m;
+            bool set;

            void check_for_interruption()
            {
@@ -74,26 +133,38 @@ namespace boost
                    throw thread_interrupted();
                }
            }
-            
+
            void operator=(interruption_checker&);
        public:
-            explicit interruption_checker(pthread_cond_t* cond):
-                thread_info(detail::get_current_thread_data())
+            explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
+                thread_info(detail::get_current_thread_data()),m(cond_mutex),
+                set(thread_info && thread_info->interrupt_enabled)
            {
-                if(thread_info && thread_info->interrupt_enabled)
+                if(set)
                {
                    lock_guard<mutex> guard(thread_info->data_mutex);
                    check_for_interruption();
+                    thread_info->cond_mutex=cond_mutex;
                    thread_info->current_cond=cond;
+                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                }
+                else
+                {
+                    BOOST_VERIFY(!pthread_mutex_lock(m));
                }
            }
            ~interruption_checker()
            {
-                if(thread_info && thread_info->interrupt_enabled)
+                if(set)
                {
+                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                    lock_guard<mutex> guard(thread_info->data_mutex);
+                    thread_info->cond_mutex=NULL;
                    thread_info->current_cond=NULL;
-                    check_for_interruption();
+                }
+                else
+                {
+                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                }
            }
        };
@@ -101,15 +172,30 @@ namespace boost

    namespace this_thread
    {
-        void BOOST_THREAD_DECL yield();
-        
-        void BOOST_THREAD_DECL sleep(system_time const& abs_time);
-        
+#ifdef BOOST_THREAD_USES_CHRONO
+        void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns);
+#endif
+        void BOOST_THREAD_DECL yield() BOOST_NOEXCEPT;
+
+#ifdef __DECXXX
+        /// Workaround of DECCXX issue of incorrect template substitution
        template<typename TimeDuration>
        inline void sleep(TimeDuration const& rel_time)
        {
            this_thread::sleep(get_system_time()+rel_time);
        }
+
+        template<>
+        void BOOST_THREAD_DECL sleep(system_time const& abs_time);
+#else
+        void BOOST_THREAD_DECL sleep(system_time const& abs_time);
+
+        template<typename TimeDuration>
+        inline BOOST_SYMBOL_VISIBLE void sleep(TimeDuration const& rel_time)
+        {
+            this_thread::sleep(get_system_time()+rel_time);
+        }
+#endif
    }
 }

--- a/include/boost/thread/pthread/thread_heap_alloc.hpp
+++ b/include/boost/thread/pthread/thread_heap_alloc.hpp
@@ -17,7 +17,7 @@ namespace boost
            return new T();
        }

-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
        template<typename T,typename A1>
        inline T* heap_new(A1&& a1)
        {
--- a/include/boost/thread/thread.hpp
+++ b/include/boost/thread/thread.hpp
@@ -3,7 +3,7 @@

 //  thread.hpp
 //
-//  (C) Copyright 2007-8 Anthony Williams 
+//  (C) Copyright 2007-8 Anthony Williams
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -20,6 +20,9 @@
 #endif

 #include <boost/thread/detail/thread.hpp>
+#include <boost/thread/detail/thread_interruption.hpp>
+#include <boost/thread/detail/thread_group.hpp>
+#include <boost/thread/v2/thread.hpp>


 #endif
--- a/include/boost/thread/thread_time.hpp
+++ b/include/boost/thread/thread_time.hpp
@@ -6,6 +6,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)

+#include <boost/date_time/time_clock.hpp>
 #include <boost/date_time/microsec_time_clock.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>

@@ -17,7 +18,11 @@ namespace boost
    
    inline system_time get_system_time()
    {
+#if defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
        return boost::date_time::microsec_clock<system_time>::universal_time();
+#else // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
+        return boost::date_time::second_clock<system_time>::universal_time();
+#endif // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
    }

    namespace detail
--- a/include/boost/thread/tss.hpp
+++ b/include/boost/thread/tss.hpp
@@ -5,6 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 // (C) Copyright 2007-8 Anthony Williams

+#include <boost/thread/detail/config.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/thread/detail/thread_heap_alloc.hpp>

@@ -61,6 +62,8 @@ namespace boost
        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
        
    public:
+        typedef T element_type;
+        
        thread_specific_ptr():
            cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
        {}
@@ -73,7 +76,7 @@ namespace boost
        }
        ~thread_specific_ptr()
        {
-            reset();
+            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,true);
        }

        T* get() const
--- a/include/boost/thread/v2/thread.hpp
+++ b/include/boost/thread/v2/thread.hpp
@@ -0,0 +1,56 @@
+// 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)
+// (C) Copyright 2011 Vicente J. Botet Escriba
+
+#ifndef BOOST_THREAD_V2_THREAD_HPP
+#define BOOST_THREAD_V2_THREAD_HPP
+
+#include <boost/thread/detail/config.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#endif
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/locks.hpp>
+
+namespace boost
+{
+  namespace this_thread
+  {
+
+#ifdef BOOST_THREAD_USES_CHRONO
+
+    template <class Rep, class Period>
+    void sleep_for(const chrono::duration<Rep, Period>& d)
+    {
+      using namespace chrono;
+      nanoseconds ns = duration_cast<nanoseconds> (d);
+      if (ns < d) ++ns;
+      sleep_for(ns);
+    }
+
+    template <class Clock, class Duration>
+    void sleep_until(const chrono::time_point<Clock, Duration>& t)
+    {
+      using namespace chrono;
+      mutex mut;
+      condition_variable cv;
+      unique_lock<mutex> lk(mut);
+      while (Clock::now() < t)
+        cv.wait_until(lk, t);
+    }
+
+    template <class Duration>
+    inline BOOST_SYMBOL_VISIBLE
+    void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
+    {
+      using namespace chrono;
+      sleep_for(t - steady_clock::now());
+    }
+
+#endif
+  }
+}
+
+
+#endif
--- a/include/boost/thread/win32/basic_recursive_mutex.hpp
+++ b/include/boost/thread/win32/basic_recursive_mutex.hpp
@@ -3,14 +3,18 @@

 //  basic_recursive_mutex.hpp
 //
-//  (C) Copyright 2006-8 Anthony Williams 
+//  (C) Copyright 2006-8 Anthony Williams
 //
 //  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 "thread_primitives.hpp"
-#include "basic_timed_mutex.hpp"
+#include <boost/thread/win32/thread_primitives.hpp>
+#include <boost/thread/win32/basic_timed_mutex.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -42,7 +46,7 @@ namespace boost
                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_basic_lock(current_thread_id);
            }
-            
+
            void lock()
            {
                long const current_thread_id=win32::GetCurrentThreadId();
@@ -64,11 +68,20 @@ namespace boost
                return timed_lock(get_system_time()+timeout);
            }

-            long get_active_count()
-            {
-                return mutex.get_active_count();
-            }
-
+#ifdef BOOST_THREAD_USES_CHRONO
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+                long const current_thread_id=win32::GetCurrentThreadId();
+                return try_recursive_lock(current_thread_id) || try_timed_lock_for(current_thread_id,rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
+        {
+                long const current_thread_id=win32::GetCurrentThreadId();
+                return try_recursive_lock(current_thread_id) || try_timed_lock_until(current_thread_id,t);
+        }
+#endif
            void unlock()
            {
                if(!--recursion_count)
@@ -78,11 +91,6 @@ namespace boost
                }
            }

-            bool locked()
-            {
-                return mutex.locked();
-            }
-            
        private:
            bool try_recursive_lock(long current_thread_id)
            {
@@ -93,7 +101,7 @@ namespace boost
                }
                return false;
            }
-            
+
            bool try_basic_lock(long current_thread_id)
            {
                if(mutex.try_lock())
@@ -104,7 +112,7 @@ namespace boost
                }
                return false;
            }
-            
+
            bool try_timed_lock(long current_thread_id,::boost::system_time const& target)
            {
                if(mutex.timed_lock(target))
@@ -115,7 +123,28 @@ namespace boost
                }
                return false;
            }
-            
+            template <typename TP>
+            bool try_timed_lock_until(long current_thread_id,TP const& target)
+            {
+                if(mutex.try_lock_until(target))
+                {
+                    BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
+                    recursion_count=1;
+                    return true;
+                }
+                return false;
+            }
+            template <typename D>
+            bool try_timed_lock_for(long current_thread_id,D const& target)
+            {
+                if(mutex.try_lock_for(target))
+                {
+                    BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
+                    recursion_count=1;
+                    return true;
+                }
+                return false;
+            }
        };

        typedef basic_recursive_mutex_impl<basic_timed_mutex> basic_recursive_mutex;
--- a/include/boost/thread/win32/basic_timed_mutex.hpp
+++ b/include/boost/thread/win32/basic_timed_mutex.hpp
@@ -3,18 +3,22 @@

 //  basic_timed_mutex_win32.hpp
 //
-//  (C) Copyright 2006-8 Anthony Williams 
+//  (C) Copyright 2006-8 Anthony Williams
 //
 //  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/assert.hpp>
-#include "thread_primitives.hpp"
-#include "interlocked_read.hpp"
+#include <boost/thread/win32/thread_primitives.hpp>
+#include <boost/thread/win32/interlocked_read.hpp>
 #include <boost/thread/thread_time.hpp>
+#include <boost/thread/xtime.hpp>
 #include <boost/detail/interlocked.hpp>
-
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif
 #include <boost/config/abi_prefix.hpp>

 namespace boost
@@ -51,24 +55,39 @@ namespace boost
                    win32::CloseHandle(old_event);
                }
            }
-            
-          
+
+
            bool try_lock()
            {
                return !win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit);
            }
-            
+
            void lock()
            {
-                BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
-            }
-            bool timed_lock(::boost::system_time const& wait_until)
-            {
-                if(!win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit))
+                if(try_lock())
                {
-                    return true;
+                    return;
                }
                long old_count=active_count;
+                mark_waiting_and_try_lock(old_count);
+
+                if(old_count&lock_flag_value)
+                {
+                    bool lock_acquired=false;
+                    void* const sem=get_event();
+
+                    do
+                    {
+                        BOOST_VERIFY(win32::WaitForSingleObject(
+                                         sem,::boost::detail::win32::infinite)==0);
+                        clear_waiting_and_try_lock(old_count);
+                        lock_acquired=!(old_count&lock_flag_value);
+                    }
+                    while(!lock_acquired);
+                }
+            }
+            void mark_waiting_and_try_lock(long& old_count)
+            {
                for(;;)
                {
                    long const new_count=(old_count&lock_flag_value)?(old_count+1):(old_count|lock_flag_value);
@@ -79,6 +98,33 @@ namespace boost
                    }
                    old_count=current;
                }
+            }
+
+            void clear_waiting_and_try_lock(long& old_count)
+            {
+                old_count&=~lock_flag_value;
+                old_count|=event_set_flag_value;
+                for(;;)
+                {
+                    long const new_count=((old_count&lock_flag_value)?old_count:((old_count-1)|lock_flag_value))&~event_set_flag_value;
+                    long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
+                    if(current==old_count)
+                    {
+                        break;
+                    }
+                    old_count=current;
+                }
+            }
+
+
+            bool timed_lock(::boost::system_time const& wait_until)
+            {
+                if(try_lock())
+                {
+                    return true;
+                }
+                long old_count=active_count;
+                mark_waiting_and_try_lock(old_count);

                if(old_count&lock_flag_value)
                {
@@ -92,18 +138,7 @@ namespace boost
                            BOOST_INTERLOCKED_DECREMENT(&active_count);
                            return false;
                        }
-                        old_count&=~lock_flag_value;
-                        old_count|=event_set_flag_value;
-                        for(;;)
-                        {
-                            long const new_count=((old_count&lock_flag_value)?old_count:((old_count-1)|lock_flag_value))&~event_set_flag_value;
-                            long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
-                            if(current==old_count)
-                            {
-                                break;
-                            }
-                            old_count=current;
-                        }
+                        clear_waiting_and_try_lock(old_count);
                        lock_acquired=!(old_count&lock_flag_value);
                    }
                    while(!lock_acquired);
@@ -111,15 +146,67 @@ namespace boost
                return true;
            }

+
            template<typename Duration>
            bool timed_lock(Duration const& timeout)
            {
                return timed_lock(get_system_time()+timeout);
            }

-            long get_active_count()
+            bool timed_lock(boost::xtime const& timeout)
            {
-                return ::boost::detail::interlocked_read_acquire(&active_count);
+                return timed_lock(system_time(timeout));
+            }
+
+            template <class Rep, class Period>
+            bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+            {
+              return try_lock_until(chrono::steady_clock::now() + rel_time);
+            }
+            template <class Clock, class Duration>
+            bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
+            {
+              using namespace chrono;
+              system_clock::time_point     s_now = system_clock::now();
+              typename Clock::time_point  c_now = Clock::now();
+              return try_lock_until(s_now + ceil<system_clock::duration>(t - c_now));
+            }
+            template <class Duration>
+            bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+            {
+              using namespace chrono;
+              typedef time_point<chrono::system_clock, chrono::system_clock::duration> sys_tmpt;
+              return try_lock_until(sys_tmpt(chrono::ceil<chrono::system_clock::duration>(t.time_since_epoch())));
+            }
+            bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::system_clock::duration>& tp)
+            {
+              if(try_lock())
+              {
+                  return true;
+              }
+              long old_count=active_count;
+              mark_waiting_and_try_lock(old_count);
+
+              if(old_count&lock_flag_value)
+              {
+                  bool lock_acquired=false;
+                  void* const sem=get_event();
+
+                  do
+                  {
+                      chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
+
+                      if(win32::WaitForSingleObject(sem,static_cast<unsigned long>(rel_time.count()))!=0)
+                      {
+                          BOOST_INTERLOCKED_DECREMENT(&active_count);
+                          return false;
+                      }
+                      clear_waiting_and_try_lock(old_count);
+                      lock_acquired=!(old_count&lock_flag_value);
+                  }
+                  while(!lock_acquired);
+              }
+              return true;
            }

            void unlock()
@@ -135,16 +222,11 @@ namespace boost
                }
            }

-            bool locked()
-            {
-                return get_active_count()>=lock_flag_value;
-            }
-            
        private:
            void* get_event()
            {
                void* current_event=::boost::detail::interlocked_read_acquire(&event);
-                
+
                if(!current_event)
                {
                    void* const new_event=win32::create_anonymous_event(win32::auto_reset_event,win32::event_initially_reset);
@@ -169,9 +251,9 @@ namespace boost
                }
                return current_event;
            }
-            
+
        };
-        
+
    }
 }

--- a/include/boost/thread/win32/condition_variable.hpp
+++ b/include/boost/thread/win32/condition_variable.hpp
@@ -6,16 +6,22 @@
 // (C) Copyright 2007-8 Anthony Williams

 #include <boost/thread/mutex.hpp>
-#include "thread_primitives.hpp"
+#include <boost/thread/win32/thread_primitives.hpp>
 #include <limits.h>
 #include <boost/assert.hpp>
 #include <algorithm>
-#include <boost/thread/thread.hpp>
+#include <boost/thread/cv_status.hpp>
+//#include <boost/thread/thread.hpp>
+#include <boost/thread/win32/thread_data.hpp>
 #include <boost/thread/thread_time.hpp>
-#include "interlocked_read.hpp"
+#include <boost/thread/win32/interlocked_read.hpp>
 #include <boost/thread/xtime.hpp>
 #include <vector>
 #include <boost/intrusive_ptr.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -26,7 +32,7 @@ namespace boost
        class basic_cv_list_entry;
        void intrusive_ptr_add_ref(basic_cv_list_entry * p);
        void intrusive_ptr_release(basic_cv_list_entry * p);
-        
+
        class basic_cv_list_entry
        {
        private:
@@ -38,7 +44,7 @@ namespace boost

            basic_cv_list_entry(basic_cv_list_entry&);
            void operator=(basic_cv_list_entry&);
-            
+
        public:
            explicit basic_cv_list_entry(detail::win32::handle_manager const& wake_sem_):
                semaphore(detail::win32::create_anonymous_semaphore(0,LONG_MAX)),
@@ -55,7 +61,7 @@ namespace boost
            {
                BOOST_INTERLOCKED_INCREMENT(&waiters);
            }
-            
+
            void remove_waiter()
            {
                BOOST_INTERLOCKED_DECREMENT(&waiters);
@@ -97,7 +103,7 @@ namespace boost
        {
            BOOST_INTERLOCKED_INCREMENT(&p->references);
        }
-            
+
        inline void intrusive_ptr_release(basic_cv_list_entry * p)
        {
            if(!BOOST_INTERLOCKED_DECREMENT(&p->references))
@@ -125,13 +131,13 @@ namespace boost
                detail::interlocked_write_release(&total_count,total_count-count_to_wake);
                detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
            }
-            
+
            template<typename lock_type>
            struct relocker
            {
                lock_type& lock;
                bool unlocked;
-                
+
                relocker(lock_type& lock_):
                    lock(lock_),unlocked(false)
                {}
@@ -146,13 +152,13 @@ namespace boost
                    {
                        lock.lock();
                    }
-                    
+
                }
            private:
                relocker(relocker&);
                void operator=(relocker&);
            };
-            
+

            entry_ptr get_wait_entry()
            {
@@ -177,15 +183,15 @@ namespace boost
                    return generations.back();
                }
            }
-            
+
            struct entry_manager
            {
                entry_ptr const entry;
-                    
+
                entry_manager(entry_ptr const& entry_):
                    entry(entry_)
                {}
-                    
+
                ~entry_manager()
                {
                    entry->remove_waiter();
@@ -200,14 +206,14 @@ namespace boost
                void operator=(entry_manager&);
                entry_manager(entry_manager&);
            };
-                
+

        protected:
            template<typename lock_type>
            bool do_wait(lock_type& lock,timeout wait_until)
            {
                relocker<lock_type> locker(lock);
-                
+
                entry_manager entry(get_wait_entry());

                locker.unlock();
@@ -219,7 +225,7 @@ namespace boost
                    {
                        return false;
                    }
-                
+
                    woken=entry->woken();
                }
                return woken;
@@ -235,7 +241,7 @@ namespace boost
                }
                return true;
            }
-        
+
            basic_condition_variable(const basic_condition_variable& other);
            basic_condition_variable& operator=(const basic_condition_variable& other);

@@ -243,11 +249,11 @@ namespace boost
            basic_condition_variable():
                total_count(0),active_generation_count(0),wake_sem(0)
            {}
-            
+
            ~basic_condition_variable()
            {}

-            void notify_one()
+            void notify_one() BOOST_NOEXCEPT
            {
                if(detail::interlocked_read_acquire(&total_count))
                {
@@ -267,8 +273,8 @@ namespace boost
                    generations.erase(std::remove_if(generations.begin(),generations.end(),&basic_cv_list_entry::no_waiters),generations.end());
                }
            }
-        
-            void notify_all()
+
+            void notify_all() BOOST_NOEXCEPT
            {
                if(detail::interlocked_read_acquire(&total_count))
                {
@@ -288,7 +294,7 @@ namespace boost
                    wake_sem=detail::win32::handle(0);
                }
            }
-        
+
        };
    }

@@ -301,10 +307,10 @@ namespace boost
    public:
        condition_variable()
        {}
-        
+
        using detail::basic_condition_variable::notify_one;
        using detail::basic_condition_variable::notify_all;
-        
+
        void wait(unique_lock<mutex>& m)
        {
            do_wait(m,detail::timeout::sentinel());
@@ -315,7 +321,7 @@ namespace boost
        {
            while(!pred()) wait(m);
        }
-        
+

        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
        {
@@ -347,8 +353,60 @@ namespace boost
        {
            return do_wait(m,wait_duration.total_milliseconds(),pred);
        }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+
+        template <class Clock, class Duration>
+        cv_status
+        wait_until(
+                unique_lock<mutex>& lock,
+                const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          do_wait(lock, ceil<milliseconds>(t-Clock::now()).count());
+          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();
+          do_wait(lock, ceil<milliseconds>(d).count());
+          return steady_clock::now() - c_now < d ? 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, class Predicate>
+        bool
+        wait_for(
+                unique_lock<mutex>& lock,
+                const chrono::duration<Rep, Period>& d,
+                Predicate pred)
+        {
+            return wait_until(lock, chrono::steady_clock::now() + d, pred);
+        }
+#endif
    };
-    
+
    class condition_variable_any:
        private detail::basic_condition_variable
    {
@@ -358,10 +416,10 @@ namespace boost
    public:
        condition_variable_any()
        {}
-        
+
        using detail::basic_condition_variable::notify_one;
        using detail::basic_condition_variable::notify_all;
-        
+
        template<typename lock_type>
        void wait(lock_type& m)
        {
@@ -373,7 +431,7 @@ namespace boost
        {
            while(!pred()) wait(m);
        }
-        
+
        template<typename lock_type>
        bool timed_wait(lock_type& m,boost::system_time const& wait_until)
        {
@@ -409,6 +467,58 @@ namespace boost
        {
            return do_wait(m,wait_duration.total_milliseconds(),pred);
        }
+#ifdef BOOST_THREAD_USES_CHRONO
+
+        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;
+          do_wait(lock, ceil<milliseconds>(t-Clock::now()).count());
+          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();
+          do_wait(lock, ceil<milliseconds>(d).count());
+          return steady_clock::now() - c_now < d ? cv_status::no_timeout :
+                                                   cv_status::timeout;
+        }
+
+        template <class lock_type, class Clock, class Duration, class Predicate>
+        bool
+        wait_until(
+                lock_type& 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 lock_type, class Rep, class Period, class Predicate>
+        bool
+        wait_for(
+                lock_type& lock,
+                const chrono::duration<Rep, Period>& d,
+                Predicate pred)
+        {
+            return wait_until(lock, chrono::steady_clock::now() + d, pred);
+        }
+#endif
    };

 }
--- a/include/boost/thread/win32/mutex.hpp
+++ b/include/boost/thread/win32/mutex.hpp
@@ -5,7 +5,7 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-#include "basic_timed_mutex.hpp"
+#include <boost/thread/win32/basic_timed_mutex.hpp>
 #include <boost/utility.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <boost/thread/locks.hpp>
@@ -20,9 +20,11 @@ namespace boost
    }

    class mutex:
-		boost::noncopyable,
        public ::boost::detail::underlying_mutex
    {
+    private:
+        mutex(mutex const&);
+        mutex& operator=(mutex const&);
    public:
        mutex()
        {
@@ -40,9 +42,11 @@ namespace boost
    typedef mutex try_mutex;

    class timed_mutex:
-        boost::noncopyable,
        public ::boost::detail::basic_timed_mutex
    {
+    private:
+        timed_mutex(timed_mutex const&);
+        timed_mutex& operator=(timed_mutex const&);
    public:
        timed_mutex()
        {
--- a/include/boost/thread/win32/once.hpp
+++ b/include/boost/thread/win32/once.hpp
@@ -30,81 +30,90 @@ namespace std

 namespace boost
 {
-    typedef long once_flag;
+    struct once_flag
+    {
+        long status;
+        long count;
+    };

-#define BOOST_ONCE_INIT 0
+#define BOOST_ONCE_INIT {0,0}

    namespace detail
    {
-        struct win32_mutex_scoped_lock
-        {
-            void* const mutex_handle;
-            explicit win32_mutex_scoped_lock(void* mutex_handle_):
-                mutex_handle(mutex_handle_)
-            {
-                BOOST_VERIFY(!win32::WaitForSingleObject(mutex_handle,win32::infinite));
-            }
-            ~win32_mutex_scoped_lock()
-            {
-                BOOST_VERIFY(win32::ReleaseMutex(mutex_handle)!=0);
-            }
-        private:
-            void operator=(win32_mutex_scoped_lock&);
-        };
-
 #ifdef BOOST_NO_ANSI_APIS
+        typedef wchar_t once_char_type;
+#else
+        typedef char once_char_type;
+#endif
+        unsigned const once_mutex_name_fixed_length=54;
+        unsigned const once_mutex_name_length=once_mutex_name_fixed_length+
+            sizeof(void*)*2+sizeof(unsigned long)*2+1;
+
        template <class I>
-        void int_to_string(I p, wchar_t* buf)
+        void int_to_string(I p, once_char_type* buf)
        {
            for(unsigned i=0; i < sizeof(I)*2; ++i,++buf)
            {
-                *buf = L'A' + static_cast<wchar_t>((p >> (i*4)) & 0x0f);
-            }
-            *buf = 0;
-        }
-#else
-        template <class I>
-        void int_to_string(I p, char* buf)
-        {
-            for(unsigned i=0; i < sizeof(I)*2; ++i,++buf)
-            {
-                *buf = 'A' + static_cast<char>((p >> (i*4)) & 0x0f);
-            }
-            *buf = 0;
-        }
-#endif
-
-        // create a named mutex. It doesn't really matter what this name is
-        // as long as it is unique both to this process, and to the address of "flag":
-        inline void* create_once_mutex(void* flag_address)
-        {
-        
 #ifdef BOOST_NO_ANSI_APIS
-            typedef wchar_t char_type;
-            static const char_type fixed_mutex_name[]=L"{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+                once_char_type const a=L'A';
 #else
-            typedef char char_type;
-            static const char_type fixed_mutex_name[]="{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+                once_char_type const a='A';
 #endif
-            unsigned const once_mutex_name_fixed_buffer_size=sizeof(fixed_mutex_name)/sizeof(char_type);
-            unsigned const once_mutex_name_fixed_length=once_mutex_name_fixed_buffer_size-1;
-            unsigned const once_mutex_name_length=once_mutex_name_fixed_buffer_size+sizeof(void*)*2+sizeof(unsigned long)*2;
-            char_type mutex_name[once_mutex_name_length];
+                *buf = a + static_cast<once_char_type>((p >> (i*4)) & 0x0f);
+            }
+            *buf = 0;
+        }
+
+        inline void name_once_mutex(once_char_type* mutex_name,void* flag_address)
+        {
+#ifdef BOOST_NO_ANSI_APIS
+            static const once_char_type fixed_mutex_name[]=L"Local\\{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+#else
+            static const once_char_type fixed_mutex_name[]="Local\\{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+#endif
+            BOOST_STATIC_ASSERT(sizeof(fixed_mutex_name) == 
+                                (sizeof(once_char_type)*(once_mutex_name_fixed_length+1)));
            
            std::memcpy(mutex_name,fixed_mutex_name,sizeof(fixed_mutex_name));
-
-            BOOST_STATIC_ASSERT(sizeof(void*) == sizeof(std::ptrdiff_t));
-            detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address), mutex_name + once_mutex_name_fixed_length);
-            detail::int_to_string(win32::GetCurrentProcessId(), mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
-
-#ifdef BOOST_NO_ANSI_APIS
-            return win32::CreateMutexW(0, 0, mutex_name);
+            detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address), 
+                                  mutex_name + once_mutex_name_fixed_length);
+            detail::int_to_string(win32::GetCurrentProcessId(), 
+                                  mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
+        }
+                        
+        inline void* open_once_event(once_char_type* mutex_name,void* flag_address)
+        {
+            if(!*mutex_name)
+            {
+                name_once_mutex(mutex_name,flag_address);
+            }
+            
+#ifdef BOOST_NO_ANSI_APIS                        
+            return ::boost::detail::win32::OpenEventW(
 #else
-            return win32::CreateMutexA(0, 0, mutex_name);
+            return ::boost::detail::win32::OpenEventA(
 #endif
+                ::boost::detail::win32::synchronize | 
+                ::boost::detail::win32::event_modify_state,
+                false,
+                mutex_name);
        }

-        
+        inline void* create_once_event(once_char_type* mutex_name,void* flag_address)
+        {
+            if(!*mutex_name)
+            {
+                name_once_mutex(mutex_name,flag_address);
+            }
+#ifdef BOOST_NO_ANSI_APIS                        
+            return ::boost::detail::win32::CreateEventW(
+#else
+            return ::boost::detail::win32::CreateEventA(
+#endif
+                0,::boost::detail::win32::manual_reset_event,
+                ::boost::detail::win32::event_initially_reset,
+                mutex_name);
+        }
    }
    

@@ -114,19 +123,79 @@ namespace boost
        // Try for a quick win: if the procedure has already been called
        // just skip through:
        long const function_complete_flag_value=0xc15730e2;
+        long const running_value=0x7f0725e3;
+        long status;
+        bool counted=false;
+        detail::win32::handle_manager event_handle;
+        detail::once_char_type mutex_name[detail::once_mutex_name_length];
+        mutex_name[0]=0;

-        if(::boost::detail::interlocked_read_acquire(&flag)!=function_complete_flag_value)
+        while((status=::boost::detail::interlocked_read_acquire(&flag.status))
+              !=function_complete_flag_value)
        {
-            void* const mutex_handle(::boost::detail::create_once_mutex(&flag));
-            BOOST_ASSERT(mutex_handle);
-            detail::win32::handle_manager const closer(mutex_handle);
-            detail::win32_mutex_scoped_lock const lock(mutex_handle);
-      
-            if(flag!=function_complete_flag_value)
+            status=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&flag.status,running_value,0);
+            if(!status)
            {
-                f();
-                BOOST_INTERLOCKED_EXCHANGE(&flag,function_complete_flag_value);
+                try
+                {
+                    if(!event_handle)
+                    {
+                        event_handle=detail::open_once_event(mutex_name,&flag);
+                    }
+                    if(event_handle)
+                    {
+                        ::boost::detail::win32::ResetEvent(event_handle);
+                    }
+                    f();
+                    if(!counted)
+                    {
+                        BOOST_INTERLOCKED_INCREMENT(&flag.count);
+                        counted=true;
+                    }
+                    BOOST_INTERLOCKED_EXCHANGE(&flag.status,function_complete_flag_value);
+                    if(!event_handle && 
+                       (::boost::detail::interlocked_read_acquire(&flag.count)>1))
+                    {
+                        event_handle=detail::create_once_event(mutex_name,&flag);
+                    }
+                    if(event_handle)
+                    {
+                        ::boost::detail::win32::SetEvent(event_handle);
+                    }
+                    break;
+                }
+                catch(...)
+                {
+                    BOOST_INTERLOCKED_EXCHANGE(&flag.status,0);
+                    if(!event_handle)
+                    {
+                        event_handle=detail::open_once_event(mutex_name,&flag);
+                    }
+                    if(event_handle)
+                    {
+                        ::boost::detail::win32::SetEvent(event_handle);
+                    }
+                    throw;
+                }
            }
+
+            if(!counted)
+            {
+                BOOST_INTERLOCKED_INCREMENT(&flag.count);
+                counted=true;
+                status=::boost::detail::interlocked_read_acquire(&flag.status);
+                if(status==function_complete_flag_value)
+                {
+                    break;
+                }
+                if(!event_handle)
+                {
+                    event_handle=detail::create_once_event(mutex_name,&flag);
+                    continue;
+                }
+            }
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObject(
+                             event_handle,::boost::detail::win32::infinite));
        }
    }
 }
--- a/include/boost/thread/win32/recursive_mutex.hpp
+++ b/include/boost/thread/win32/recursive_mutex.hpp
@@ -3,7 +3,7 @@

 //  recursive_mutex.hpp
 //
-//  (C) Copyright 2006-7 Anthony Williams 
+//  (C) Copyright 2006-7 Anthony Williams
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -11,7 +11,7 @@


 #include <boost/utility.hpp>
-#include "basic_recursive_mutex.hpp"
+#include <boost/thread/win32/basic_recursive_mutex.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <boost/thread/locks.hpp>

@@ -20,9 +20,11 @@
 namespace boost
 {
    class recursive_mutex:
-        boost::noncopyable,
        public ::boost::detail::basic_recursive_mutex
    {
+    private:
+        recursive_mutex(recursive_mutex const&);
+        recursive_mutex& operator=(recursive_mutex const&);
    public:
        recursive_mutex()
        {
@@ -40,9 +42,11 @@ namespace boost
    typedef recursive_mutex recursive_try_mutex;

    class recursive_timed_mutex:
-        boost::noncopyable,
        public ::boost::detail::basic_recursive_timed_mutex
    {
+    private:
+        recursive_timed_mutex(recursive_timed_mutex const&);
+        recursive_timed_mutex& operator=(recursive_timed_mutex const&);
    public:
        recursive_timed_mutex()
        {
--- a/include/boost/thread/win32/shared_mutex.hpp
+++ b/include/boost/thread/win32/shared_mutex.hpp
@@ -14,14 +14,26 @@
 #include <limits.h>
 #include <boost/utility.hpp>
 #include <boost/thread/thread_time.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/ceil.hpp>
+#endif

 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
-    class shared_mutex:
-        private boost::noncopyable
+    class shared_mutex
    {
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+    public:
+        shared_mutex(shared_mutex const&) = delete;
+        shared_mutex& operator=(shared_mutex const&) = delete;
+#else // BOOST_NO_DELETED_FUNCTIONS
+    private:
+        shared_mutex(shared_mutex const&);
+        shared_mutex& operator=(shared_mutex const&);
+#endif // BOOST_NO_DELETED_FUNCTIONS
    private:
        struct state_data
        {
@@ -37,7 +49,7 @@ namespace boost
                return *reinterpret_cast<unsigned const*>(&lhs)==*reinterpret_cast<unsigned const*>(&rhs);
            }
        };
-        
+

        template<typename T>
        T interlocked_compare_exchange(T* target,T new_value,T comparand)
@@ -49,34 +61,47 @@ namespace boost
            return *reinterpret_cast<T const*>(&res);
        }

+        enum
+        {
+            unlock_sem = 0,
+            exclusive_sem = 1
+        };
+
        state_data state;
        detail::win32::handle semaphores[2];
-        detail::win32::handle &unlock_sem;
-        detail::win32::handle &exclusive_sem;
        detail::win32::handle upgrade_sem;

        void release_waiters(state_data old_state)
        {
            if(old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::win32::ReleaseSemaphore(exclusive_sem,1,0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
            }
-                        
+
            if(old_state.shared_waiting || old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
            }
        }
-        
+

    public:
-        shared_mutex():
-            unlock_sem(semaphores[0]),
-            exclusive_sem(semaphores[1]) 
+        shared_mutex()
        {
-            unlock_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
-            exclusive_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
-            upgrade_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            semaphores[unlock_sem]=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            semaphores[exclusive_sem]=detail::win32::create_anonymous_semaphore_nothrow(0,LONG_MAX);
+            if (!semaphores[exclusive_sem])
+            {
+              detail::win32::release_semaphore(semaphores[unlock_sem],LONG_MAX);
+              boost::throw_exception(thread_resource_error());
+            }
+            upgrade_sem=detail::win32::create_anonymous_semaphore_nothrow(0,LONG_MAX);
+            if (!upgrade_sem)
+            {
+              detail::win32::release_semaphore(semaphores[unlock_sem],LONG_MAX);
+              detail::win32::release_semaphore(semaphores[exclusive_sem],LONG_MAX);
+              boost::throw_exception(thread_resource_error());
+            }
            state_data state_={0};
            state=state_;
        }
@@ -84,21 +109,25 @@ namespace boost
        ~shared_mutex()
        {
            detail::win32::CloseHandle(upgrade_sem);
-            detail::win32::CloseHandle(unlock_sem);
-            detail::win32::CloseHandle(exclusive_sem);
+            detail::win32::CloseHandle(semaphores[unlock_sem]);
+            detail::win32::CloseHandle(semaphores[exclusive_sem]);
        }

        bool try_lock_shared()
        {
            state_data old_state=state;
-            do
+            for(;;)
            {
                state_data new_state=old_state;
                if(!new_state.exclusive && !new_state.exclusive_waiting_blocked)
                {
                    ++new_state.shared_count;
+                    if(!new_state.shared_count)
+                    {
+                        return false;
+                    }
                }
-                
+
                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                if(current_state==old_state)
                {
@@ -106,14 +135,6 @@ namespace boost
                }
                old_state=current_state;
            }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
            return !(old_state.exclusive| old_state.exclusive_waiting_blocked);
        }

@@ -130,26 +151,27 @@ namespace boost

        bool timed_lock_shared(boost::system_time const& wait_until)
        {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true)
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
+            for(;;)
            {
                state_data old_state=state;
-                do
+                for(;;)
                {
                    state_data new_state=old_state;
                    if(new_state.exclusive || new_state.exclusive_waiting_blocked)
                    {
                        ++new_state.shared_waiting;
+                        if(!new_state.shared_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
                    }
                    else
                    {
                        ++new_state.shared_count;
+                        if(!new_state.shared_count)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
                    }

                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
@@ -159,24 +181,16 @@ namespace boost
                    }
                    old_state=current_state;
                }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-                while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif

                if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
                {
                    return true;
                }
-                    
-                unsigned long const res=detail::win32::WaitForSingleObject(unlock_sem,::boost::detail::get_milliseconds_until(wait_until));
+
+                unsigned long const res=detail::win32::WaitForSingleObject(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until));
                if(res==detail::win32::timeout)
                {
-                    do
+                    for(;;)
                    {
                        state_data new_state=old_state;
                        if(new_state.exclusive || new_state.exclusive_waiting_blocked)
@@ -189,6 +203,10 @@ namespace boost
                        else
                        {
                            ++new_state.shared_count;
+                            if(!new_state.shared_count)
+                            {
+                                return false;
+                            }
                        }

                        state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
@@ -198,14 +216,6 @@ namespace boost
                        }
                        old_state=current_state;
                    }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-                    while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif

                    if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
                    {
@@ -213,19 +223,126 @@ namespace boost
                    }
                    return false;
                }
-                
+
                BOOST_ASSERT(res==0);
            }
        }

+        template <class Rep, class Period>
+        bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
+          typename Clock::time_point  c_now = Clock::now();
+          return try_lock_shared_until(s_now + ceil<system_clock::duration>(t - c_now));
+        }
+        template <class Duration>
+        bool try_lock_shared_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<chrono::system_clock, chrono::system_clock::duration> sys_tmpt;
+          return try_lock_shared_until(sys_tmpt(chrono::ceil<chrono::system_clock::duration>(t.time_since_epoch())));
+        }
+        bool try_lock_shared_until(const chrono::time_point<chrono::system_clock, chrono::system_clock::duration>& tp)
+        {
+          for(;;)
+          {
+            state_data old_state=state;
+            for(;;)
+            {
+              state_data new_state=old_state;
+              if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+              {
+                  ++new_state.shared_waiting;
+                  if(!new_state.shared_waiting)
+                  {
+                      boost::throw_exception(boost::lock_error());
+                  }
+              }
+              else
+              {
+                  ++new_state.shared_count;
+                  if(!new_state.shared_count)
+                  {
+                      boost::throw_exception(boost::lock_error());
+                  }
+              }
+
+              state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+              if(current_state==old_state)
+              {
+                  break;
+              }
+              old_state=current_state;
+            }
+
+            if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+            {
+              return true;
+            }
+
+            chrono::system_clock::time_point n = chrono::system_clock::now();
+            unsigned long res;
+            if (tp>n) {
+              chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-n);
+              res=detail::win32::WaitForSingleObject(semaphores[unlock_sem],
+                static_cast<unsigned long>(rel_time.count()));
+            } else {
+              res=detail::win32::timeout;
+            }
+            if(res==detail::win32::timeout)
+            {
+              for(;;)
+              {
+                state_data new_state=old_state;
+                if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+                {
+                  if(new_state.shared_waiting)
+                  {
+                      --new_state.shared_waiting;
+                  }
+                }
+                else
+                {
+                  ++new_state.shared_count;
+                  if(!new_state.shared_count)
+                  {
+                      return false;
+                  }
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+              }
+
+              if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+              {
+                return true;
+              }
+              return false;
+            }
+
+            BOOST_ASSERT(res==0);
+          }
+        }
+
        void unlock_shared()
        {
            state_data old_state=state;
-            do
+            for(;;)
            {
                state_data new_state=old_state;
                bool const last_reader=!--new_state.shared_count;
-                
+
                if(last_reader)
                {
                    if(new_state.upgrade)
@@ -243,7 +360,7 @@ namespace boost
                        new_state.shared_waiting=0;
                    }
                }
-                
+
                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                if(current_state==old_state)
                {
@@ -262,14 +379,6 @@ namespace boost
                }
                old_state=current_state;
            }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
        }

        void lock()
@@ -283,25 +392,49 @@ namespace boost
            return timed_lock(get_system_time()+relative_time);
        }

+        bool try_lock()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                if(new_state.shared_count || new_state.exclusive)
+                {
+                    return false;
+                }
+                else
+                {
+                    new_state.exclusive=true;
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            return true;
+        }
+
+
        bool timed_lock(boost::system_time const& wait_until)
        {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true)
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
+            for(;;)
            {
                state_data old_state=state;

-                do
+                for(;;)
                {
                    state_data new_state=old_state;
                    if(new_state.shared_count || new_state.exclusive)
                    {
                        ++new_state.exclusive_waiting;
+                        if(!new_state.exclusive_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+
                        new_state.exclusive_waiting_blocked=true;
                    }
                    else
@@ -316,23 +449,20 @@ namespace boost
                    }
                    old_state=current_state;
                }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-                while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif

                if(!old_state.shared_count && !old_state.exclusive)
                {
                    return true;
                }
-                unsigned long const wait_res=detail::win32::WaitForMultipleObjects(2,semaphores,true,::boost::detail::get_milliseconds_until(wait_until));
+                #ifndef UNDER_CE
+                const bool wait_all = true;
+                #else
+                const bool wait_all = false;
+                #endif
+                unsigned long const wait_res=detail::win32::WaitForMultipleObjects(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until));
                if(wait_res==detail::win32::timeout)
                {
-                    do
+                    for(;;)
                    {
                        state_data new_state=old_state;
                        if(new_state.shared_count || new_state.exclusive)
@@ -357,14 +487,6 @@ namespace boost
                        }
                        old_state=current_state;
                    }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-                    while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
                    if(!old_state.shared_count && !old_state.exclusive)
                    {
                        return true;
@@ -375,10 +497,119 @@ namespace boost
            }
        }

+
+        template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+        {
+          return try_lock_until(chrono::steady_clock::now() + rel_time);
+        }
+        template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
+        {
+          using namespace chrono;
+          system_clock::time_point     s_now = system_clock::now();
+          typename Clock::time_point  c_now = Clock::now();
+          return try_lock_until(s_now + ceil<system_clock::duration>(t - c_now));
+        }
+        template <class Duration>
+        bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
+        {
+          using namespace chrono;
+          typedef time_point<chrono::system_clock, chrono::system_clock::duration> sys_tmpt;
+          return try_lock_until(sys_tmpt(chrono::ceil<chrono::system_clock::duration>(t.time_since_epoch())));
+        }
+        bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::system_clock::duration>& tp)
+        {
+          for(;;)
+          {
+            state_data old_state=state;
+
+            for(;;)
+            {
+              state_data new_state=old_state;
+              if(new_state.shared_count || new_state.exclusive)
+              {
+                ++new_state.exclusive_waiting;
+                if(!new_state.exclusive_waiting)
+                {
+                    boost::throw_exception(boost::lock_error());
+                }
+
+                new_state.exclusive_waiting_blocked=true;
+              }
+              else
+              {
+                new_state.exclusive=true;
+              }
+
+              state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+              if(current_state==old_state)
+              {
+                break;
+              }
+              old_state=current_state;
+            }
+
+            if(!old_state.shared_count && !old_state.exclusive)
+            {
+                return true;
+            }
+            #ifndef UNDER_CE
+            const bool wait_all = true;
+            #else
+            const bool wait_all = false;
+            #endif
+
+            chrono::system_clock::time_point n = chrono::system_clock::now();
+            unsigned long wait_res;
+            if (tp>n) {
+              chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
+              wait_res=detail::win32::WaitForMultipleObjects(2,semaphores,wait_all,
+                  static_cast<unsigned long>(rel_time.count()));
+            } else {
+              wait_res=detail::win32::timeout;
+            }
+            if(wait_res==detail::win32::timeout)
+            {
+              for(;;)
+              {
+                state_data new_state=old_state;
+                if(new_state.shared_count || new_state.exclusive)
+                {
+                  if(new_state.exclusive_waiting)
+                  {
+                    if(!--new_state.exclusive_waiting)
+                    {
+                      new_state.exclusive_waiting_blocked=false;
+                    }
+                  }
+                }
+                else
+                {
+                  new_state.exclusive=true;
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                  break;
+                }
+                old_state=current_state;
+              }
+              if(!old_state.shared_count && !old_state.exclusive)
+              {
+                return true;
+              }
+              return false;
+            }
+            BOOST_ASSERT(wait_res<2);
+          }
+        }
+
        void unlock()
        {
            state_data old_state=state;
-            do
+            for(;;)
            {
                state_data new_state=old_state;
                new_state.exclusive=false;
@@ -396,39 +627,32 @@ namespace boost
                }
                old_state=current_state;
            }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
            release_waiters(old_state);
        }

        void lock_upgrade()
        {
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true)
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
+            for(;;)
            {
                state_data old_state=state;
-                do
+                for(;;)
                {
                    state_data new_state=old_state;
                    if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
                    {
                        ++new_state.shared_waiting;
+                        if(!new_state.shared_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
                    }
                    else
                    {
                        ++new_state.shared_count;
+                        if(!new_state.shared_count)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
                        new_state.upgrade=true;
                    }

@@ -439,33 +663,55 @@ namespace boost
                    }
                    old_state=current_state;
                }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-                while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif

                if(!(old_state.exclusive|| old_state.exclusive_waiting_blocked|| old_state.upgrade))
                {
                    return;
                }
-                    
-                BOOST_VERIFY(!detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite));
+
+                BOOST_VERIFY(!detail::win32::WaitForSingleObject(semaphores[unlock_sem],detail::win32::infinite));
            }
        }

+        bool try_lock_upgrade()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
+                {
+                    return false;
+                }
+                else
+                {
+                    ++new_state.shared_count;
+                    if(!new_state.shared_count)
+                    {
+                        return false;
+                    }
+                    new_state.upgrade=true;
+                }
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            return true;
+        }
+
        void unlock_upgrade()
        {
            state_data old_state=state;
-            do
+            for(;;)
            {
                state_data new_state=old_state;
                new_state.upgrade=false;
                bool const last_reader=!--new_state.shared_count;
-                
+
                if(last_reader)
                {
                    if(new_state.exclusive_waiting)
@@ -475,42 +721,36 @@ namespace boost
                    }
                    new_state.shared_waiting=0;
                }
-                
+
                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                if(current_state==old_state)
                {
                    if(last_reader)
                    {
                        release_waiters(old_state);
+                    } else {
+                        release_waiters(old_state);
                    }
                    break;
                }
                old_state=current_state;
            }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
        }

        void unlock_upgrade_and_lock()
        {
            state_data old_state=state;
-            do
+            for(;;)
            {
                state_data new_state=old_state;
                bool const last_reader=!--new_state.shared_count;
-                
+
                if(last_reader)
                {
                    new_state.upgrade=false;
                    new_state.exclusive=true;
                }
-                
+
                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                if(current_state==old_state)
                {
@@ -522,20 +762,12 @@ namespace boost
                }
                old_state=current_state;
            }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
        }

        void unlock_and_lock_upgrade()
        {
            state_data old_state=state;
-            do
+            for(;;)
            {
                state_data new_state=old_state;
                new_state.exclusive=false;
@@ -555,21 +787,34 @@ namespace boost
                }
                old_state=current_state;
            }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
            release_waiters(old_state);
        }
-        
+//        bool try_unlock_upgrade_and_lock()
+//        {
+//          return false;
+//        }
+//#ifdef BOOST_THREAD_USES_CHRONO
+//        template <class Rep, class Period>
+//        bool
+//        try_unlock_upgrade_and_lock_for(
+//                                const chrono::duration<Rep, Period>& rel_time)
+//        {
+//          return try_unlock_upgrade_and_lock_until(
+//                                 chrono::steady_clock::now() + rel_time);
+//        }
+//        template <class Clock, class Duration>
+//        bool
+//        try_unlock_upgrade_and_lock_until(
+//                          const chrono::time_point<Clock, Duration>& abs_time)
+//        {
+//          return false;
+//        }
+//#endif
+
        void unlock_and_lock_shared()
        {
            state_data old_state=state;
-            do
+            for(;;)
            {
                state_data new_state=old_state;
                new_state.exclusive=false;
@@ -588,21 +833,12 @@ namespace boost
                }
                old_state=current_state;
            }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
            release_waiters(old_state);
        }
-        
        void unlock_upgrade_and_lock_shared()
        {
            state_data old_state=state;
-            do
+            for(;;)
            {
                state_data new_state=old_state;
                new_state.upgrade=false;
@@ -620,18 +856,12 @@ namespace boost
                }
                old_state=current_state;
            }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127)
-#endif
-            while(true);
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
            release_waiters(old_state);
        }
-        
+
    };
+    typedef shared_mutex upgrade_mutex;
+
 }

 #include <boost/config/abi_suffix.hpp>
--- a/include/boost/thread/win32/thread_data.hpp
+++ b/include/boost/thread/win32/thread_data.hpp
@@ -8,13 +8,53 @@
 #include <boost/thread/detail/config.hpp>
 #include <boost/intrusive_ptr.hpp>
 #include <boost/thread/thread_time.hpp>
-#include "thread_primitives.hpp"
-#include "thread_heap_alloc.hpp"
-
+#include <boost/thread/win32/thread_primitives.hpp>
+#include <boost/thread/win32/thread_heap_alloc.hpp>
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/system_clocks.hpp>
+#endif
 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
+  class thread_attributes {
+  public:
+      thread_attributes() {
+        val_.stack_size = 0;
+        //val_.lpThreadAttributes=0;
+      }
+      ~thread_attributes() {
+      }
+      // stack size
+      void set_stack_size(std::size_t size) {
+        val_.stack_size = size;
+      }
+
+      std::size_t get_stack_size() const {
+          return val_.stack_size;
+      }
+
+      //void set_security(LPSECURITY_ATTRIBUTES lpThreadAttributes)
+      //{
+      //  val_.lpThreadAttributes=lpThreadAttributes;
+      //}
+      //LPSECURITY_ATTRIBUTES get_security()
+      //{
+      //  return val_.lpThreadAttributes;
+      //}
+
+      struct win_attrs {
+        std::size_t stack_size;
+        //LPSECURITY_ATTRIBUTES lpThreadAttributes;
+      };
+      typedef win_attrs native_handle_type;
+      native_handle_type* native_handle() {return &val_;}
+      const native_handle_type* native_handle() const {return &val_;}
+
+  private:
+      win_attrs val_;
+  };
+
    namespace detail
    {
        struct thread_exit_callback_node;
@@ -23,8 +63,8 @@ namespace boost
        struct thread_data_base;
        void intrusive_ptr_add_ref(thread_data_base * p);
        void intrusive_ptr_release(thread_data_base * p);
-        
-        struct thread_data_base
+
+        struct BOOST_SYMBOL_VISIBLE thread_data_base
        {
            long count;
            detail::win32::handle_manager thread_handle;
@@ -48,7 +88,7 @@ namespace boost
            {
                BOOST_INTERLOCKED_INCREMENT(&p->count);
            }
-            
+
            friend void intrusive_ptr_release(thread_data_base * p)
            {
                if(!BOOST_INTERLOCKED_DECREMENT(&p->count))
@@ -61,7 +101,7 @@ namespace boost
            {
                BOOST_VERIFY(detail::win32::SetEvent(interruption_handle)!=0);
            }
-            
+
            typedef detail::win32::handle native_handle_type;

            virtual void run()=0;
@@ -69,7 +109,7 @@ namespace boost

        typedef boost::intrusive_ptr<detail::thread_data_base> thread_data_ptr;

-        struct timeout
+        struct BOOST_SYMBOL_VISIBLE timeout
        {
            unsigned long start;
            uintmax_t milliseconds;
@@ -92,7 +132,7 @@ namespace boost
                abs_time(abs_time_)
            {}

-            struct remaining_time
+            struct BOOST_SYMBOL_VISIBLE remaining_time
            {
                bool more;
                unsigned long milliseconds;
@@ -130,7 +170,7 @@ namespace boost
            {
                return milliseconds==~uintmax_t(0);
            }
-            
+

            static timeout sentinel()
            {
@@ -139,38 +179,49 @@ namespace boost
        private:
            struct sentinel_type
            {};
-                
+
            explicit timeout(sentinel_type):
                start(0),milliseconds(~uintmax_t(0)),relative(true)
            {}
        };
+
+        inline uintmax_t pin_to_zero(intmax_t value)
+        {
+            return (value<0)?0u:(uintmax_t)value;
+        }
    }

    namespace this_thread
    {
-        void BOOST_THREAD_DECL yield();
+        void BOOST_THREAD_DECL yield() BOOST_NOEXCEPT;

        bool BOOST_THREAD_DECL interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time);
-        inline void interruptible_wait(unsigned long milliseconds)
+        inline void interruptible_wait(uintmax_t milliseconds)
        {
            interruptible_wait(detail::win32::invalid_handle_value,milliseconds);
        }
-        inline void interruptible_wait(system_time const& abs_time)
+        inline BOOST_SYMBOL_VISIBLE void interruptible_wait(system_time const& abs_time)
        {
            interruptible_wait(detail::win32::invalid_handle_value,abs_time);
        }

        template<typename TimeDuration>
-        inline void sleep(TimeDuration const& rel_time)
+        inline BOOST_SYMBOL_VISIBLE void sleep(TimeDuration const& rel_time)
        {
-            interruptible_wait(static_cast<unsigned long>(rel_time.total_milliseconds()));
+            interruptible_wait(detail::pin_to_zero(rel_time.total_milliseconds()));
        }
-        inline void sleep(system_time const& abs_time)
+        inline BOOST_SYMBOL_VISIBLE void sleep(system_time const& abs_time)
        {
            interruptible_wait(abs_time);
        }
+#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
    }
-    
+
 }

 #include <boost/config/abi_suffix.hpp>
--- a/include/boost/thread/win32/thread_heap_alloc.hpp
+++ b/include/boost/thread/win32/thread_heap_alloc.hpp
@@ -5,9 +5,10 @@
 #ifndef THREAD_HEAP_ALLOC_HPP
 #define THREAD_HEAP_ALLOC_HPP
 #include <new>
-#include "thread_primitives.hpp"
+#include <boost/thread/win32/thread_primitives.hpp>
 #include <stdexcept>
 #include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>

 #if defined( BOOST_USE_WINDOWS_H )
 # include <windows.h>
@@ -55,21 +56,21 @@ namespace boost
 {
    namespace detail
    {
-        inline BOOST_THREAD_DECL void* allocate_raw_heap_memory(unsigned size)
+        inline void* allocate_raw_heap_memory(unsigned size)
        {
            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,size);
            if(!heap_memory)
            {
-                throw std::bad_alloc();
+                boost::throw_exception(std::bad_alloc());
            }
            return heap_memory;
        }

-        inline BOOST_THREAD_DECL void free_raw_heap_memory(void* heap_memory)
+        inline void free_raw_heap_memory(void* heap_memory)
        {
            BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0);
        }
-            
+
        template<typename T>
        inline T* heap_new()
        {
@@ -86,7 +87,7 @@ namespace boost
            }
        }

-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
        template<typename T,typename A1>
        inline T* heap_new(A1&& a1)
        {
@@ -225,7 +226,7 @@ namespace boost
        {
            return heap_new_impl<T,A1&>(a1);
        }
-        
+
        template<typename T,typename A1,typename A2>
        inline T* heap_new(A1 const& a1,A2 const& a2)
        {
@@ -371,8 +372,8 @@ namespace boost
        {
            return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
        }
-        
-#endif        
+
+#endif
        template<typename T>
        inline void heap_delete(T* data)
        {
--- a/include/boost/thread/win32/thread_primitives.hpp
+++ b/include/boost/thread/win32/thread_primitives.hpp
@@ -3,14 +3,15 @@

 //  win32_thread_primitives.hpp
 //
-//  (C) Copyright 2005-7 Anthony Williams 
-//  (C) Copyright 2007 David Deakins 
+//  (C) Copyright 2005-7 Anthony Williams
+//  (C) Copyright 2007 David Deakins
 //
 //  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>
+#include <boost/throw_exception.hpp>
 #include <boost/assert.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <boost/detail/interlocked.hpp>
@@ -30,14 +31,18 @@ namespace boost
            unsigned const infinite=INFINITE;
            unsigned const timeout=WAIT_TIMEOUT;
            handle const invalid_handle_value=INVALID_HANDLE_VALUE;
+            unsigned const event_modify_state=EVENT_MODIFY_STATE;
+            unsigned const synchronize=SYNCHRONIZE;

 # ifdef BOOST_NO_ANSI_APIS
            using ::CreateMutexW;
            using ::CreateEventW;
+            using ::OpenEventW;
            using ::CreateSemaphoreW;
 # else
            using ::CreateMutexA;
            using ::CreateEventA;
+            using ::OpenEventA;
            using ::CreateSemaphoreA;
 # endif
            using ::CloseHandle;
@@ -64,7 +69,7 @@ namespace boost
 # ifdef UNDER_CE
 #  ifndef WINAPI
 #   ifndef _WIN32_WCE_EMULATION
-#    define WINAPI  __cdecl	// Note this doesn't match the desktop definition
+#    define WINAPI  __cdecl     // Note this doesn't match the desktop definition
 #   else
 #    define WINAPI  __stdcall
 #   endif
@@ -89,7 +94,7 @@ namespace boost
    {
        namespace win32
        {
-            
+
 # ifdef _WIN64
            typedef unsigned __int64 ulong_ptr;
 # else
@@ -99,6 +104,8 @@ namespace boost
            unsigned const infinite=~0U;
            unsigned const timeout=258U;
            handle const invalid_handle_value=(handle)(-1);
+            unsigned const event_modify_state=2;
+            unsigned const synchronize=0x100000u;

            extern "C"
            {
@@ -107,10 +114,12 @@ namespace boost
                __declspec(dllimport) void* __stdcall CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
                __declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
                __declspec(dllimport) void* __stdcall CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall OpenEventW(unsigned long,int,wchar_t const*);
 # else
                __declspec(dllimport) void* __stdcall CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
                __declspec(dllimport) void* __stdcall CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
                __declspec(dllimport) void* __stdcall CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+                __declspec(dllimport) void* __stdcall OpenEventA(unsigned long,int,char const*);
 # endif
                __declspec(dllimport) int __stdcall CloseHandle(void*);
                __declspec(dllimport) int __stdcall ReleaseMutex(void*);
@@ -161,40 +170,49 @@ namespace boost
                auto_reset_event=false,
                manual_reset_event=true
            };
-            
+
            enum initial_event_state
            {
                event_initially_reset=false,
                event_initially_set=true
            };
-            
+
            inline handle create_anonymous_event(event_type type,initial_event_state state)
            {
-#if !defined(BOOST_NO_ANSI_APIS)  
+#if !defined(BOOST_NO_ANSI_APIS)
                handle const res=win32::CreateEventA(0,type,state,0);
 #else
                handle const res=win32::CreateEventW(0,type,state,0);
-#endif                
+#endif
                if(!res)
                {
-                    throw thread_resource_error();
+                    boost::throw_exception(thread_resource_error());
                }
                return res;
            }

            inline handle create_anonymous_semaphore(long initial_count,long max_count)
            {
-#if !defined(BOOST_NO_ANSI_APIS)  
+#if !defined(BOOST_NO_ANSI_APIS)
                handle const res=CreateSemaphoreA(0,initial_count,max_count,0);
 #else
                handle const res=CreateSemaphoreW(0,initial_count,max_count,0);
-#endif               
+#endif
                if(!res)
                {
-                    throw thread_resource_error();
+                    boost::throw_exception(thread_resource_error());
                }
                return res;
            }
+            inline handle create_anonymous_semaphore_nothrow(long initial_count,long max_count)
+            {
+#if !defined(BOOST_NO_ANSI_APIS)
+                handle const res=CreateSemaphoreA(0,initial_count,max_count,0);
+#else
+                handle const res=CreateSemaphoreW(0,initial_count,max_count,0);
+#endif
+                return res;
+            }

            inline handle duplicate_handle(handle source)
            {
@@ -204,7 +222,7 @@ namespace boost
                bool const success=DuplicateHandle(current_process,source,current_process,&new_handle,0,false,same_access_flag)!=0;
                if(!success)
                {
-                    throw thread_resource_error();
+                    boost::throw_exception(thread_resource_error());
                }
                return new_handle;
            }
@@ -228,7 +246,7 @@ namespace boost
                        BOOST_VERIFY(CloseHandle(handle_to_manage));
                    }
                }
-                
+
            public:
                explicit handle_manager(handle handle_to_manage_):
                    handle_to_manage(handle_to_manage_)
@@ -236,7 +254,7 @@ namespace boost
                handle_manager():
                    handle_to_manage(0)
                {}
-                
+
                handle_manager& operator=(handle new_handle)
                {
                    cleanup();
@@ -270,28 +288,18 @@ namespace boost
                {
                    return !handle_to_manage;
                }
-                
+
                ~handle_manager()
                {
                    cleanup();
                }
            };
-            
+
        }
    }
 }

 #if defined(BOOST_MSVC) && (_MSC_VER>=1400)  && !defined(UNDER_CE)
-#if _MSC_VER==1400
-extern "C" unsigned char _interlockedbittestandset(long *a,long b);
-extern "C" unsigned char _interlockedbittestandreset(long *a,long b);
-#else
-extern "C" unsigned char _interlockedbittestandset(volatile long *a,long b);
-extern "C" unsigned char _interlockedbittestandreset(volatile long *a,long b);
-#endif
-
-#pragma intrinsic(_interlockedbittestandset)
-#pragma intrinsic(_interlockedbittestandreset)

 namespace boost
 {
@@ -299,6 +307,17 @@ namespace boost
    {
        namespace win32
        {
+#if _MSC_VER==1400
+            extern "C" unsigned char _interlockedbittestandset(long *a,long b);
+            extern "C" unsigned char _interlockedbittestandreset(long *a,long b);
+#else
+            extern "C" unsigned char _interlockedbittestandset(volatile long *a,long b);
+            extern "C" unsigned char _interlockedbittestandreset(volatile long *a,long b);
+#endif
+
+#pragma intrinsic(_interlockedbittestandset)
+#pragma intrinsic(_interlockedbittestandreset)
+
            inline bool interlocked_bit_test_and_set(long* x,long bit)
            {
                return _interlockedbittestandset(x,bit)!=0;
@@ -308,7 +327,7 @@ namespace boost
            {
                return _interlockedbittestandreset(x,bit)!=0;
            }
-            
+
        }
    }
 }
@@ -327,7 +346,7 @@ namespace boost
                    mov edx,x;
                    lock bts [edx],eax;
                    setc al;
-                };          
+                };
            }

            inline bool interlocked_bit_test_and_reset(long* x,long bit)
@@ -337,9 +356,9 @@ namespace boost
                    mov edx,x;
                    lock btr [edx],eax;
                    setc al;
-                };          
+                };
            }
-            
+
        }
    }
 }
--- a/src/future.cpp
+++ b/src/future.cpp
@@ -0,0 +1,56 @@
+// (C) Copyright 2012 Vicente J. Botet Escriba
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/future.hpp>
+
+namespace boost
+{
+
+  namespace thread_detail
+  {
+
+    class  future_error_category :
+      public boost::system::error_category
+    {
+    public:
+        virtual const char* name() const; //BOOST_NOEXCEPT;
+        virtual std::string message(int ev) const;
+    };
+
+    const char*
+    future_error_category::name() const //BOOST_NOEXCEPT
+    {
+        return "future";
+    }
+
+    std::string
+    future_error_category::message(int ev) const
+    {
+        switch (BOOST_SCOPED_ENUM_NATIVE(future_errc)(ev))
+        {
+        case future_errc::broken_promise:
+            return std::string("The associated promise has been destructed prior "
+                          "to the associated state becoming ready.");
+        case future_errc::future_already_retrieved:
+            return std::string("The future has already been retrieved from "
+                          "the promise or packaged_task.");
+        case future_errc::promise_already_satisfied:
+            return std::string("The state of the promise has already been set.");
+        case future_errc::no_state:
+            return std::string("Operation not permitted on an object without "
+                          "an associated state.");
+        }
+        return std::string("unspecified future_errc value\n");
+    }
+  }
+
+  const system::error_category&
+  future_category()
+  {
+      static thread_detail::future_error_category f;
+      return f;
+  }
+
+}
--- a/src/pthread/exceptions.cpp
+++ b/src/pthread/exceptions.cpp
@@ -1,124 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  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/thread/exceptions.hpp>
-#include <cstring>
-#include <string>
-
-namespace boost {
-
-thread_exception::thread_exception()
-    : m_sys_err(0)
-{
-}
-
-thread_exception::thread_exception(int sys_err_code)
-    : m_sys_err(sys_err_code)
-{
-}
-
-thread_exception::~thread_exception() throw()
-{
-}
-
-int thread_exception::native_error() const
-{
-    return m_sys_err; 
-}
-
-lock_error::lock_error()
-{
-}
-
-lock_error::lock_error(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-lock_error::~lock_error() throw()
-{
-}
-
-const char* lock_error::what() const throw()
-{
-    return "boost::lock_error";
-}
-
-thread_resource_error::thread_resource_error()
-{
-}
-
-thread_resource_error::thread_resource_error(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-thread_resource_error::~thread_resource_error() throw()
-{
-}
-
-const char* thread_resource_error::what() const throw()
-{
-    return "boost::thread_resource_error";
-}
-
-unsupported_thread_option::unsupported_thread_option()
-{
-}
-
-unsupported_thread_option::unsupported_thread_option(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-unsupported_thread_option::~unsupported_thread_option() throw()
-{
-}
-
-const char* unsupported_thread_option::what() const throw()
-{
-    return "boost::unsupported_thread_option";
-}
-
-invalid_thread_argument::invalid_thread_argument()
-{
-}
-
-invalid_thread_argument::invalid_thread_argument(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-invalid_thread_argument::~invalid_thread_argument() throw()
-{
-}
-
-const char* invalid_thread_argument::what() const throw()
-{
-    return "boost::invalid_thread_argument";
-}
-
-thread_permission_error::thread_permission_error()
-{
-}
-
-thread_permission_error::thread_permission_error(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-thread_permission_error::~thread_permission_error() throw()
-{
-}
-
-const char* thread_permission_error::what() const throw()
-{
-    return "boost::thread_permission_error";
-}
-
-} // namespace boost
--- a/src/pthread/once.cpp
+++ b/src/pthread/once.cpp
@@ -1,6 +1,6 @@
 // Copyright (C) 2007 Anthony Williams
 //
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  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 __STDC_CONSTANT_MACROS
@@ -8,6 +8,7 @@
 #include <boost/assert.hpp>
 #include <pthread.h>
 #include <stdlib.h>
+#include <memory>

 namespace boost
 {
@@ -21,19 +22,39 @@ namespace boost
        {
            pthread_key_t epoch_tss_key;
            pthread_once_t epoch_tss_key_flag=PTHREAD_ONCE_INIT;
-            
-            extern "C" void delete_epoch_tss_data(void* data)
+
+            extern "C"
            {
-                free(data);
+                static void delete_epoch_tss_data(void* data)
+                {
+                    free(data);
+                }
+
+                static void create_epoch_tss_key()
+                {
+                    BOOST_VERIFY(!pthread_key_create(&epoch_tss_key,delete_epoch_tss_data));
+                }
            }

-            extern "C" void create_epoch_tss_key()
+#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
            {
-                BOOST_VERIFY(!pthread_key_create(&epoch_tss_key,delete_epoch_tss_data));
-            }
-            
+                delete_epoch_tss_key_on_dlclose_t()
+                {
+                }
+                ~delete_epoch_tss_key_on_dlclose_t()
+                {
+                    if(memcmp(&epoch_tss_key_flag, &pthread_once_init_value, sizeof(pthread_once_t)))
+                    {
+                        pthread_key_delete(epoch_tss_key);
+                    }
+                }
+            };
+            delete_epoch_tss_key_on_dlclose_t delete_epoch_tss_key_on_dlclose;
+#endif
        }
-        
+
        boost::uintmax_t& get_once_per_thread_epoch()
        {
            BOOST_VERIFY(!pthread_once(&epoch_tss_key_flag,create_epoch_tss_key));
@@ -47,5 +68,5 @@ namespace boost
            return *static_cast<boost::uintmax_t*>(data);
        }
    }
-    
+
 }
--- a/src/pthread/thread.cpp
+++ b/src/pthread/thread.cpp
@@ -1,8 +1,9 @@
 // Copyright (C) 2001-2003
 // William E. Kempf
 // Copyright (C) 2007-8 Anthony Williams
+// (C) Copyright 2011 Vicente J. Botet Escriba
 //
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  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>
@@ -13,12 +14,13 @@
 #include <boost/thread/locks.hpp>
 #include <boost/thread/once.hpp>
 #include <boost/thread/tss.hpp>
-#ifdef __linux__
+#include <boost/throw_exception.hpp>
+#ifdef __GLIBC__
 #include <sys/sysinfo.h>
 #elif defined(__APPLE__) || defined(__FreeBSD__)
 #include <sys/types.h>
 #include <sys/sysctl.h>
-#elif defined(__sun) || defined(__CYGWIN__)
+#elif defined BOOST_HAS_UNISTD_H
 #include <unistd.h>
 #endif

@@ -42,19 +44,6 @@ namespace boost
            {}
        };

-        struct tss_data_node
-        {
-            void const* key;
-            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
-            void* value;
-            tss_data_node* next;
-
-            tss_data_node(void const* key_,boost::shared_ptr<boost::detail::tss_cleanup_function> func_,void* value_,
-                          tss_data_node* next_):
-                key(key_),func(func_),value(value_),next(next_)
-            {}
-        };
-
        namespace
        {
            boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
@@ -62,12 +51,12 @@ namespace boost

            extern "C"
            {
-                void tls_destructor(void* data)
+                static void tls_destructor(void* data)
                {
                    boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
                    if(thread_info)
                    {
-                        while(thread_info->tss_data || thread_info->thread_exit_callbacks)
+                        while(!thread_info->tss_data.empty() || thread_info->thread_exit_callbacks)
                        {
                            while(thread_info->thread_exit_callbacks)
                            {
@@ -80,29 +69,49 @@ namespace boost
                                }
                                delete current_node;
                            }
-                            while(thread_info->tss_data)
+                            for(std::map<void const*,tss_data_node>::iterator next=thread_info->tss_data.begin(),
+                                    current,
+                                    end=thread_info->tss_data.end();
+                                next!=end;)
                            {
-                                detail::tss_data_node* const current_node=thread_info->tss_data;
-                                thread_info->tss_data=current_node->next;
-                                if(current_node->func)
+                                current=next;
+                                ++next;
+                                if(current->second.func && (current->second.value!=0))
                                {
-                                    (*current_node->func)(current_node->value);
+                                    (*current->second.func)(current->second.value);
                                }
-                                delete current_node;
+                                thread_info->tss_data.erase(current);
                            }
                        }
                        thread_info->self.reset();
                    }
                }
            }
-    
+
+#if defined BOOST_THREAD_PATCH
+
+            struct  delete_current_thread_tls_key_on_dlclose_t
+            {
+                delete_current_thread_tls_key_on_dlclose_t()
+                {
+                }
+                ~delete_current_thread_tls_key_on_dlclose_t()
+                {
+                    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()
            {
                BOOST_VERIFY(!pthread_key_create(&current_thread_tls_key,&tls_destructor));
            }
        }
-        
+
        boost::detail::thread_data_base* get_current_thread_data()
        {
            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
@@ -115,12 +124,12 @@ namespace boost
            BOOST_VERIFY(!pthread_setspecific(current_thread_tls_key,new_data));
        }
    }
-    
+
    namespace
    {
        extern "C"
        {
-            void* thread_proxy(void* param)
+            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();
@@ -132,10 +141,12 @@ namespace boost
                catch(thread_interrupted const&)
                {
                }
-                catch(...)
-                {
-                    std::terminate();
-                }
+// Removed as it stops the debugger identifying the cause of the exception
+// Unhandled exceptions still cause the application to terminate
+//                 catch(...)
+//                 {
+//                     std::terminate();
+//                 }

                detail::tls_destructor(thread_info.get());
                detail::set_current_thread_data(0);
@@ -153,7 +164,7 @@ namespace boost
            {
                interrupt_enabled=false;
            }
-            
+
            void run()
            {}

@@ -184,7 +195,7 @@ namespace boost
    }


-    thread::thread()
+    thread::thread() BOOST_NOEXCEPT
    {}

    void thread::start_thread()
@@ -192,10 +203,45 @@ namespace boost
        thread_info->self=thread_info;
        int const res = pthread_create(&thread_info->thread_handle, 0, &thread_proxy, thread_info.get());
        if (res != 0)
+        {
+            thread_info->self.reset();
+            boost::throw_exception(thread_resource_error(res, "boost thread: failed in pthread_create"));
+        }
+    }
+
+    void thread::start_thread(const attributes& attr)
+    {
+        thread_info->self=thread_info;
+        const attributes::native_handle_type* h = attr.native_handle();
+        int res = pthread_create(&thread_info->thread_handle, h, &thread_proxy, thread_info.get());
+        if (res != 0)
        {
            thread_info->self.reset();
            throw thread_resource_error();
        }
+        int detached_state;
+        res = pthread_attr_getdetachstate(h, &detached_state);
+        if (res != 0)
+        {
+            thread_info->self.reset();
+            throw thread_resource_error();
+        }
+        if (PTHREAD_CREATE_DETACHED==detached_state)
+        {
+          detail::thread_data_ptr local_thread_info;
+          thread_info.swap(local_thread_info);
+
+          if(local_thread_info)
+          {
+              //lock_guard<mutex> lock(local_thread_info->data_mutex);
+              if(!local_thread_info->join_started)
+              {
+                  //BOOST_VERIFY(!pthread_detach(local_thread_info->thread_handle));
+                  local_thread_info->join_started=true;
+                  local_thread_info->joined=true;
+              }
+          }
+        }
    }

    thread::~thread()
@@ -203,19 +249,22 @@ namespace boost
        detach();
    }

-    detail::thread_data_ptr thread::get_thread_info() const
+    detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const
    {
-        lock_guard<mutex> l(thread_info_mutex);
        return thread_info;
    }

    void thread::join()
    {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        if (this_thread::get_id() == get_id())
+        {
+            boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
+        }
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            bool do_join=false;
-            
+
            {
                unique_lock<mutex> lock(local_thread_info->data_mutex);
                while(!local_thread_info->done)
@@ -223,7 +272,7 @@ namespace boost
                    local_thread_info->done_condition.wait(lock);
                }
                do_join=!local_thread_info->join_started;
-                
+
                if(do_join)
                {
                    local_thread_info->join_started=true;
@@ -244,8 +293,7 @@ namespace boost
                local_thread_info->joined=true;
                local_thread_info->done_condition.notify_all();
            }
-            
-            lock_guard<mutex> l1(thread_info_mutex);
+
            if(thread_info==local_thread_info)
            {
                thread_info.reset();
@@ -253,24 +301,28 @@ namespace boost
        }
    }

-    bool thread::timed_join(system_time const& wait_until)
+    bool thread::do_try_join_until(struct timespec const &timeout)
    {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        if (this_thread::get_id() == get_id())
+        {
+            boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
+        }
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            bool do_join=false;
-            
+
            {
                unique_lock<mutex> lock(local_thread_info->data_mutex);
                while(!local_thread_info->done)
                {
-                    if(!local_thread_info->done_condition.timed_wait(lock,wait_until))
+                    if(!local_thread_info->done_condition.do_timed_wait(lock,timeout))
                    {
                        return false;
                    }
                }
                do_join=!local_thread_info->join_started;
-                
+
                if(do_join)
                {
                    local_thread_info->join_started=true;
@@ -291,8 +343,7 @@ namespace boost
                local_thread_info->joined=true;
                local_thread_info->done_condition.notify_all();
            }
-            
-            lock_guard<mutex> l1(thread_info_mutex);
+
            if(thread_info==local_thread_info)
            {
                thread_info.reset();
@@ -301,20 +352,17 @@ namespace boost
        return true;
    }

-    bool thread::joinable() const
+    bool thread::joinable() const BOOST_NOEXCEPT
    {
-        return get_thread_info();
+        return (get_thread_info)();
    }


    void thread::detach()
    {
        detail::thread_data_ptr local_thread_info;
-        {
-            lock_guard<mutex> l1(thread_info_mutex);
-            thread_info.swap(local_thread_info);
-        }
-        
+        thread_info.swap(local_thread_info);
+
        if(local_thread_info)
        {
            lock_guard<mutex> lock(local_thread_info->data_mutex);
@@ -329,11 +377,15 @@ namespace boost

    namespace this_thread
    {
-        
+
+#ifdef __DECXXX
+        /// Workaround of DECCXX issue of incorrect template substitution
+        template<>
+#endif
        void sleep(const system_time& st)
        {
            detail::thread_data_base* const thread_info=detail::get_current_thread_data();
-        
+
            if(thread_info)
            {
                unique_lock<mutex> lk(thread_info->sleep_mutex);
@@ -342,7 +394,7 @@ namespace boost
            else
            {
                xtime const xt=get_xtime(st);
-            
+
                for (int foo=0; foo < 5; ++foo)
                {
 #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
@@ -352,7 +404,7 @@ namespace boost
 #   elif defined(BOOST_HAS_NANOSLEEP)
                    timespec ts;
                    to_timespec_duration(xt, ts);
-                
+
                    //  nanosleep takes a timespec that is an offset, not
                    //  an absolute time.
                    nanosleep(&ts, 0);
@@ -370,7 +422,34 @@ namespace boost
            }
        }

-        void yield()
+#ifdef BOOST_THREAD_USES_CHRONO
+        void
+        sleep_for(const chrono::nanoseconds& ns)
+        {
+            using namespace chrono;
+            if (ns >= nanoseconds::zero())
+            {
+                timespec ts;
+                ts.tv_sec = static_cast<long>(duration_cast<seconds>(ns).count());
+                ts.tv_nsec = static_cast<long>((ns - seconds(ts.tv_sec)).count());
+
+#   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
+                BOOST_VERIFY(!pthread_delay_np(&ts));
+#   elif defined(BOOST_HAS_NANOSLEEP)
+                //  nanosleep takes a timespec that is an offset, not
+                //  an absolute time.
+                nanosleep(&ts, 0);
+#   else
+                mutex mx;
+                mutex::scoped_lock lock(mx);
+                condition_variable cond;
+                cond.wait_for(lock, ns);
+#   endif
+            }
+        }
+#endif
+
+        void yield() BOOST_NOEXCEPT
        {
 #   if defined(BOOST_HAS_SCHED_YIELD)
            BOOST_VERIFY(!sched_yield());
@@ -383,28 +462,27 @@ namespace boost
 #   endif
        }
    }
-
-    unsigned thread::hardware_concurrency()
+    unsigned thread::hardware_concurrency() BOOST_NOEXCEPT
    {
 #if defined(PTW32_VERSION) || defined(__hpux)
        return pthread_num_processors_np();
-#elif defined(__linux__)
-        return get_nprocs();
 #elif defined(__APPLE__) || defined(__FreeBSD__)
        int count;
        size_t size=sizeof(count);
        return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
-#elif defined(__sun) || defined(__CYGWIN__)
+#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
        int const count=sysconf(_SC_NPROCESSORS_ONLN);
        return (count>0)?count:0;
+#elif defined(__GLIBC__)
+        return get_nprocs();
 #else
        return 0;
 #endif
    }

-    thread::id thread::get_id() const
+    thread::id thread::get_id() const BOOST_NOEXCEPT
    {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            return id(local_thread_info);
@@ -417,13 +495,14 @@ namespace boost

    void thread::interrupt()
    {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            lock_guard<mutex> lk(local_thread_info->data_mutex);
            local_thread_info->interrupt_requested=true;
            if(local_thread_info->current_cond)
            {
+                boost::pthread::pthread_mutex_scoped_lock internal_lock(local_thread_info->cond_mutex);
                BOOST_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond));
            }
        }
@@ -431,7 +510,7 @@ namespace boost

    bool thread::interruption_requested() const
    {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            lock_guard<mutex> lk(local_thread_info->data_mutex);
@@ -445,7 +524,7 @@ namespace boost

    thread::native_handle_type thread::native_handle()
    {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            lock_guard<mutex> lk(local_thread_info->data_mutex);
@@ -456,12 +535,12 @@ namespace boost
            return pthread_t();
        }
    }
-    
-    
+
+

    namespace this_thread
    {
-        thread::id get_id()
+        thread::id get_id() BOOST_NOEXCEPT
        {
            boost::detail::thread_data_base* const thread_info=get_or_make_current_thread_data();
            return thread::id(thread_info?thread_info->shared_from_this():detail::thread_data_ptr());
@@ -480,13 +559,13 @@ namespace boost
                }
            }
        }
-        
+
        bool interruption_enabled()
        {
            boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data();
            return thread_info && thread_info->interrupt_enabled;
        }
-        
+
        bool interruption_requested()
        {
            boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data();
@@ -509,7 +588,7 @@ namespace boost
                detail::get_current_thread_data()->interrupt_enabled=false;
            }
        }
-        
+
        disable_interruption::~disable_interruption()
        {
            if(detail::get_current_thread_data())
@@ -525,7 +604,7 @@ namespace boost
                detail::get_current_thread_data()->interrupt_enabled=true;
            }
        }
-        
+
        restore_interruption::~restore_interruption()
        {
            if(detail::get_current_thread_data())
@@ -550,14 +629,11 @@ namespace boost
            detail::thread_data_base* const current_thread_data(get_current_thread_data());
            if(current_thread_data)
            {
-                detail::tss_data_node* current_node=current_thread_data->tss_data;
-                while(current_node)
+                std::map<void const*,tss_data_node>::iterator current_node=
+                    current_thread_data->tss_data.find(key);
+                if(current_node!=current_thread_data->tss_data.end())
                {
-                    if(current_node->key==key)
-                    {
-                        return current_node;
-                    }
-                    current_node=current_node->next;
+                    return &current_node->second;
                }
            }
            return NULL;
@@ -571,106 +647,47 @@ namespace boost
            }
            return NULL;
        }
-        
-        void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing)
+
+        void add_new_tss_node(void const* key,
+                              boost::shared_ptr<tss_cleanup_function> func,
+                              void* tss_data)
+        {
+            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
+            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(func,tss_data)));
+        }
+
+        void erase_tss_node(void const* key)
+        {
+            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
+            current_thread_data->tss_data.erase(key);
+        }
+
+        void set_tss_data(void const* key,
+                          boost::shared_ptr<tss_cleanup_function> func,
+                          void* tss_data,bool cleanup_existing)
        {
            if(tss_data_node* const current_node=find_tss_data(key))
            {
-                if(cleanup_existing && current_node->func)
+                if(cleanup_existing && current_node->func && (current_node->value!=0))
                {
                    (*current_node->func)(current_node->value);
                }
-                current_node->func=func;
-                current_node->value=tss_data;
+                if(func || (tss_data!=0))
+                {
+                    current_node->func=func;
+                    current_node->value=tss_data;
+                }
+                else
+                {
+                    erase_tss_node(key);
+                }
            }
            else
            {
-                detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-                tss_data_node* const new_node=new tss_data_node(key,func,tss_data,current_thread_data->tss_data);
-                current_thread_data->tss_data=new_node;
+                add_new_tss_node(key,func,tss_data);
            }
        }
    }

-//     thread_group::thread_group()
-//     {
-//     }
-
-//     thread_group::~thread_group()
-//     {
-//         // We shouldn't have to scoped_lock here, since referencing this object
-//         // from another thread while we're deleting it in the current thread is
-//         // going to lead to undefined behavior any way.
-//         for (std::list<thread*>::iterator it = m_threads.begin();
-//              it != m_threads.end(); ++it)
-//         {
-//             delete (*it);
-//         }
-//     }
-
-//     thread* thread_group::create_thread(const function0<void>& threadfunc)
-//     {
-//         // No scoped_lock required here since the only "shared data" that's
-//         // modified here occurs inside add_thread which does scoped_lock.
-//         std::auto_ptr<thread> thrd(new thread(threadfunc));
-//         add_thread(thrd.get());
-//         return thrd.release();
-//     }
-
-//     void thread_group::add_thread(thread* thrd)
-//     {
-//         mutex::scoped_lock scoped_lock(m_mutex);
-
-//         // For now we'll simply ignore requests to add a thread object multiple
-//         // times. Should we consider this an error and either throw or return an
-//         // error value?
-//         std::list<thread*>::iterator it = std::find(m_threads.begin(),
-//                                                     m_threads.end(), thrd);
-//         BOOST_ASSERT(it == m_threads.end());
-//         if (it == m_threads.end())
-//             m_threads.push_back(thrd);
-//     }
-
-//     void thread_group::remove_thread(thread* thrd)
-//     {
-//         mutex::scoped_lock scoped_lock(m_mutex);
-
-//         // For now we'll simply ignore requests to remove a thread object that's
-//         // not in the group. Should we consider this an error and either throw or
-//         // return an error value?
-//         std::list<thread*>::iterator it = std::find(m_threads.begin(),
-//                                                     m_threads.end(), thrd);
-//         BOOST_ASSERT(it != m_threads.end());
-//         if (it != m_threads.end())
-//             m_threads.erase(it);
-//     }
-
-//     void thread_group::join_all()
-//     {
-//         mutex::scoped_lock scoped_lock(m_mutex);
-//         for (std::list<thread*>::iterator it = m_threads.begin();
-//              it != m_threads.end(); ++it)
-//         {
-//             (*it)->join();
-//         }
-//     }
-
-//     void thread_group::interrupt_all()
-//     {
-//         boost::lock_guard<mutex> guard(m_mutex);
-            
-//         for(std::list<thread*>::iterator it=m_threads.begin(),end=m_threads.end();
-//             it!=end;
-//             ++it)
-//         {
-//             (*it)->interrupt();
-//         }
-//     }
-        
-
-//     size_t thread_group::size() const
-//     {
-//         return m_threads.size();
-//     }

 }
--- a/src/pthread/timeconv.inl
+++ b/src/pthread/timeconv.inl
@@ -1,11 +1,14 @@
 // Copyright (C) 2001-2003
 // William E. Kempf
+// Copyright (C) 2009 Anthony Williams
 //
 //  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)

 // boostinspect:nounnamed

+#include <boost/assert.hpp>
+
 namespace {
 const int MILLISECONDS_PER_SECOND = 1000;
 const int NANOSECONDS_PER_SECOND = 1000000000;
@@ -18,7 +21,7 @@ inline void to_time(int milliseconds, boost::xtime& xt)
 {
    int res = 0;
    res = boost::xtime_get(&xt, boost::TIME_UTC);
-    assert(res == boost::TIME_UTC);
+    BOOST_ASSERT(res == boost::TIME_UTC); (void)res;

    xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
    xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) *
@@ -30,7 +33,6 @@ inline void to_time(int milliseconds, boost::xtime& xt)
        xt.nsec -= NANOSECONDS_PER_SECOND;
    }
 }
-
 #if defined(BOOST_HAS_PTHREADS)
 inline void to_timespec(const boost::xtime& xt, timespec& ts)
 {
@@ -55,7 +57,7 @@ inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
    boost::xtime cur;
    int res = 0;
    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    assert(res == boost::TIME_UTC);
+    BOOST_ASSERT(res == boost::TIME_UTC); (void)res;

    if (boost::xtime_cmp(xt, cur) <= 0)
    {
@@ -86,7 +88,7 @@ inline void to_duration(boost::xtime xt, int& milliseconds)
    boost::xtime cur;
    int res = 0;
    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    assert(res == boost::TIME_UTC);
+    BOOST_ASSERT(res == boost::TIME_UTC); (void)res;

    if (boost::xtime_cmp(xt, cur) <= 0)
        milliseconds = 0;
@@ -108,7 +110,7 @@ inline void to_microduration(boost::xtime xt, int& microseconds)
    boost::xtime cur;
    int res = 0;
    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    assert(res == boost::TIME_UTC);
+    BOOST_ASSERT(res == boost::TIME_UTC); (void)res;

    if (boost::xtime_cmp(xt, cur) <= 0)
        microseconds = 0;
--- a/src/tss_null.cpp
+++ b/src/tss_null.cpp
@@ -8,13 +8,15 @@

 #if defined(BOOST_HAS_WINTHREADS) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))

+namespace boost 
+{
    /*
    This file is a "null" implementation of tss cleanup; it's
    purpose is to to eliminate link errors in cases
    where it is known that tss cleanup is not needed.
    */

-    extern "C" void tss_cleanup_implemented(void)
+    void tss_cleanup_implemented(void)
    {
        /*
        This function's sole purpose is to cause a link error in cases where
@@ -30,5 +32,7 @@
        longer needed and can be removed.
        */
    }
+	
+}

 #endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)
--- a/src/win32/exceptions.cpp
+++ b/src/win32/exceptions.cpp
@@ -1,124 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  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/thread/exceptions.hpp>
-#include <cstring>
-#include <string>
-
-namespace boost {
-
-thread_exception::thread_exception()
-    : m_sys_err(0)
-{
-}
-
-thread_exception::thread_exception(int sys_err_code)
-    : m_sys_err(sys_err_code)
-{
-}
-
-thread_exception::~thread_exception() throw()
-{
-}
-
-int thread_exception::native_error() const
-{
-    return m_sys_err; 
-}
-
-lock_error::lock_error()
-{
-}
-
-lock_error::lock_error(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-lock_error::~lock_error() throw()
-{
-}
-
-const char* lock_error::what() const throw()
-{
-    return "boost::lock_error";
-}
-
-thread_resource_error::thread_resource_error()
-{
-}
-
-thread_resource_error::thread_resource_error(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-thread_resource_error::~thread_resource_error() throw()
-{
-}
-
-const char* thread_resource_error::what() const throw()
-{
-    return "boost::thread_resource_error";
-}
-
-unsupported_thread_option::unsupported_thread_option()
-{
-}
-
-unsupported_thread_option::unsupported_thread_option(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-unsupported_thread_option::~unsupported_thread_option() throw()
-{
-}
-
-const char* unsupported_thread_option::what() const throw()
-{
-    return "boost::unsupported_thread_option";
-}
-
-invalid_thread_argument::invalid_thread_argument()
-{
-}
-
-invalid_thread_argument::invalid_thread_argument(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-invalid_thread_argument::~invalid_thread_argument() throw()
-{
-}
-
-const char* invalid_thread_argument::what() const throw()
-{
-    return "boost::invalid_thread_argument";
-}
-
-thread_permission_error::thread_permission_error()
-{
-}
-
-thread_permission_error::thread_permission_error(int sys_err_code)
-    : thread_exception(sys_err_code)
-{
-}
-
-thread_permission_error::~thread_permission_error() throw()
-{
-}
-
-const char* thread_permission_error::what() const throw()
-{
-    return "boost::thread_permission_error";
-}
-
-} // namespace boost
--- a/src/win32/thread.cpp
+++ b/src/win32/thread.cpp
@@ -9,7 +9,6 @@

 #include <boost/thread/thread.hpp>
 #include <algorithm>
-#include <windows.h>
 #ifndef UNDER_CE
 #include <process.h>
 #endif
@@ -17,35 +16,60 @@
 #include <boost/thread/once.hpp>
 #include <boost/thread/tss.hpp>
 #include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>
 #include <boost/thread/detail/tss_hooks.hpp>
 #include <boost/date_time/posix_time/conversion.hpp>
+#include <windows.h>
+#include <memory>

 namespace boost
 {
    namespace
    {
        boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
-        DWORD current_thread_tls_key=0;
+        #if defined(UNDER_CE)
+        // Windows CE does not define the TLS_OUT_OF_INDEXES constant.
+        DWORD tls_out_of_index=0xFFFFFFFF;
+        #else
+        DWORD tls_out_of_index=TLS_OUT_OF_INDEXES;
+        #endif
+        DWORD current_thread_tls_key=tls_out_of_index;

        void create_current_thread_tls_key()
        {
+            tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in
            current_thread_tls_key=TlsAlloc();
-            BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);
+            BOOST_ASSERT(current_thread_tls_key!=tls_out_of_index);
+        }
+
+        void cleanup_tls_key()
+        {
+            if(current_thread_tls_key!=tls_out_of_index)
+            {
+                TlsFree(current_thread_tls_key);
+                current_thread_tls_key=tls_out_of_index;
+            }
        }

        detail::thread_data_base* get_current_thread_data()
        {
-            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
+            if(current_thread_tls_key==tls_out_of_index)
+            {
+                return 0;
+            }
            return (detail::thread_data_base*)TlsGetValue(current_thread_tls_key);
        }

        void set_current_thread_data(detail::thread_data_base* new_data)
        {
            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
-            BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
+            if(current_thread_tls_key!=tls_out_of_index)
+                BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
+            else
+                boost::throw_exception(thread_resource_error());
        }

-#ifdef BOOST_NO_THREADEX
+#ifndef BOOST_HAS_THREADEX
 // Windows CE doesn't define _beginthreadex

        struct ThreadProxyData
@@ -58,22 +82,25 @@ namespace boost

        DWORD WINAPI ThreadProxy(LPVOID args)
        {
-            ThreadProxyData* data=reinterpret_cast<ThreadProxyData*>(args);
+            std::auto_ptr<ThreadProxyData> data(reinterpret_cast<ThreadProxyData*>(args));
            DWORD ret=data->start_address_(data->arglist_);
-            delete data;
            return ret;
        }
-        
+
        typedef void* uintptr_t;

        inline uintptr_t const _beginthreadex(void* security, unsigned stack_size, unsigned (__stdcall* start_address)(void*),
                                              void* arglist, unsigned initflag, unsigned* thrdaddr)
        {
            DWORD threadID;
+            ThreadProxyData* data = new ThreadProxyData(start_address,arglist);
            HANDLE hthread=CreateThread(static_cast<LPSECURITY_ATTRIBUTES>(security),stack_size,ThreadProxy,
-                                        new ThreadProxyData(start_address,arglist),initflag,&threadID);
-            if (hthread!=0)
-                *thrdaddr=threadID;
+                                        data,initflag,&threadID);
+            if (hthread==0) {
+              delete data;
+              return 0;
+            }
+            *thrdaddr=threadID;
            return reinterpret_cast<uintptr_t const>(hthread);
        }

@@ -140,11 +167,11 @@ namespace boost
                        boost::detail::heap_delete(current_node);
                    }
                }
-                
+
+                set_current_thread_data(0);
            }
-            set_current_thread_data(0);
        }
-        
+
        unsigned __stdcall thread_start_function(void* param)
        {
            detail::thread_data_base* const thread_info(reinterpret_cast<detail::thread_data_base*>(param));
@@ -156,16 +183,18 @@ namespace boost
            catch(thread_interrupted const&)
            {
            }
-            catch(...)
-            {
-                std::terminate();
-            }
+// Removed as it stops the debugger identifying the cause of the exception
+// Unhandled exceptions still cause the application to terminate
+//             catch(...)
+//             {
+//                 std::terminate();
+//             }
            run_thread_exit_callbacks();
            return 0;
        }
    }

-    thread::thread()
+    thread::thread() BOOST_NOEXCEPT
    {}

    void thread::start_thread()
@@ -173,13 +202,26 @@ namespace boost
        uintptr_t const new_thread=_beginthreadex(0,0,&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);
        if(!new_thread)
        {
-            throw thread_resource_error();
+            boost::throw_exception(thread_resource_error());
        }
        intrusive_ptr_add_ref(thread_info.get());
        thread_info->thread_handle=(detail::win32::handle)(new_thread);
        ResumeThread(thread_info->thread_handle);
    }

+    void thread::start_thread(const attributes& attr)
+    {
+      //uintptr_t const new_thread=_beginthreadex(attr.get_security(),attr.get_stack_size(),&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);
+      uintptr_t const new_thread=_beginthreadex(0,attr.get_stack_size(),&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);
+      if(!new_thread)
+      {
+          boost::throw_exception(thread_resource_error());
+      }
+      intrusive_ptr_add_ref(thread_info.get());
+      thread_info->thread_handle=(detail::win32::handle)(new_thread);
+      ResumeThread(thread_info->thread_handle);
+    }
+
    thread::thread(detail::thread_data_ptr data):
        thread_info(data)
    {}
@@ -194,7 +236,7 @@ namespace boost
                ++count;
                interruption_enabled=false;
            }
-            
+
            void run()
            {}
        private:
@@ -205,7 +247,15 @@ namespace boost
        void make_external_thread_data()
        {
            externally_launched_thread* me=detail::heap_new<externally_launched_thread>();
-            set_current_thread_data(me);
+            try
+            {
+                set_current_thread_data(me);
+            }
+            catch(...)
+            {
+                detail::heap_delete(me);
+                throw;
+            }
        }

        detail::thread_data_base* get_or_make_current_thread_data()
@@ -218,27 +268,31 @@ namespace boost
            }
            return current_thread_data;
        }
-        
+
    }

    thread::~thread()
    {
        detach();
    }
-    
-    thread::id thread::get_id() const
+
+    thread::id thread::get_id() const BOOST_NOEXCEPT
    {
-        return thread::id(get_thread_info());
+        return thread::id((get_thread_info)());
    }

-    bool thread::joinable() const
+    bool thread::joinable() const BOOST_NOEXCEPT
    {
-        return get_thread_info();
+        return (get_thread_info)();
    }

    void thread::join()
    {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        if (this_thread::get_id() == get_id())
+        {
+            boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
+        }
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            this_thread::interruptible_wait(local_thread_info->thread_handle,detail::timeout::sentinel());
@@ -248,7 +302,11 @@ namespace boost

    bool thread::timed_join(boost::system_time const& wait_until)
    {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        if (this_thread::get_id() == get_id())
+        {
+            boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
+        }
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            if(!this_thread::interruptible_wait(local_thread_info->thread_handle,get_milliseconds_until(wait_until)))
@@ -259,7 +317,30 @@ namespace boost
        }
        return true;
    }
-    
+
+#ifdef BOOST_THREAD_USES_CHRONO
+
+    bool thread::try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
+    {
+      if (this_thread::get_id() == get_id())
+      {
+        boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
+      }
+      detail::thread_data_ptr local_thread_info=(get_thread_info)();
+      if(local_thread_info)
+      {
+        chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
+        if(!this_thread::interruptible_wait(local_thread_info->thread_handle,rel_time.count()))
+        {
+            return false;
+        }
+        release_handle();
+      }
+      return true;
+    }
+
+#endif
+
    void thread::detach()
    {
        release_handle();
@@ -267,41 +348,39 @@ namespace boost

    void thread::release_handle()
    {
-        lock_guard<mutex> l1(thread_info_mutex);
        thread_info=0;
    }
-    
+
    void thread::interrupt()
    {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
        if(local_thread_info)
        {
            local_thread_info->interrupt();
        }
    }
-    
+
    bool thread::interruption_requested() const
    {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
        return local_thread_info.get() && (detail::win32::WaitForSingleObject(local_thread_info->interruption_handle,0)==0);
    }
-    
-    unsigned thread::hardware_concurrency()
+
+    unsigned thread::hardware_concurrency() BOOST_NOEXCEPT
    {
-        SYSTEM_INFO info={0};
+        SYSTEM_INFO info={{0}};
        GetSystemInfo(&info);
        return info.dwNumberOfProcessors;
    }
-    
+
    thread::native_handle_type thread::native_handle()
    {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
        return local_thread_info?(detail::win32::handle)local_thread_info->thread_handle:detail::win32::invalid_handle_value;
    }

-    detail::thread_data_ptr thread::get_thread_info() const
+    detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const
    {
-        boost::mutex::scoped_lock l(thread_info_mutex);
        return thread_info;
    }

@@ -311,7 +390,7 @@ namespace boost
        {
            LARGE_INTEGER get_due_time(detail::timeout const&  target_time)
            {
-                LARGE_INTEGER due_time={0};
+                LARGE_INTEGER due_time={{0}};
                if(target_time.relative)
                {
                    unsigned long const elapsed_milliseconds=GetTickCount()-target_time.start;
@@ -340,13 +419,29 @@ namespace boost
                    else
                    {
                        long const hundred_nanoseconds_in_one_second=10000000;
-                        due_time.QuadPart+=target_time.abs_time.time_of_day().fractional_seconds()*(hundred_nanoseconds_in_one_second/target_time.abs_time.time_of_day().ticks_per_second());
+                        posix_time::time_duration::tick_type const ticks_per_second=
+                            target_time.abs_time.time_of_day().ticks_per_second();
+                        if(ticks_per_second>hundred_nanoseconds_in_one_second)
+                        {
+                            posix_time::time_duration::tick_type const
+                                ticks_per_hundred_nanoseconds=
+                                ticks_per_second/hundred_nanoseconds_in_one_second;
+                            due_time.QuadPart+=
+                                target_time.abs_time.time_of_day().fractional_seconds()/
+                                ticks_per_hundred_nanoseconds;
+                        }
+                        else
+                        {
+                            due_time.QuadPart+=
+                                target_time.abs_time.time_of_day().fractional_seconds()*
+                                (hundred_nanoseconds_in_one_second/ticks_per_second);
+                        }
                    }
                }
                return due_time;
            }
        }
-        
+

        bool interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time)
        {
@@ -367,10 +462,10 @@ namespace boost
            }

            detail::win32::handle_manager timer_handle;
-            
+
 #ifndef UNDER_CE
            unsigned const min_timer_wait_period=20;
-            
+
            if(!target_time.is_sentinel())
            {
                detail::timeout::remaining_time const time_left=target_time.remaining_milliseconds();
@@ -381,7 +476,7 @@ namespace boost
                    if(timer_handle!=0)
                    {
                        LARGE_INTEGER due_time=get_due_time(target_time);
-                        
+
                        bool const set_time_succeeded=SetWaitableTimer(timer_handle,&due_time,0,0,0,false)!=0;
                        if(set_time_succeeded)
                        {
@@ -397,17 +492,17 @@ namespace boost
                }
            }
 #endif
-        
+
            bool const using_timer=timeout_index!=~0u;
            detail::timeout::remaining_time time_left(0);
-            
+
            do
            {
                if(!using_timer)
                {
                    time_left=target_time.remaining_milliseconds();
                }
-                
+
                if(handle_count)
                {
                    unsigned long const notified_index=detail::win32::WaitForMultipleObjects(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds);
@@ -441,7 +536,7 @@ namespace boost
            return false;
        }

-        thread::id get_id()
+        thread::id get_id() BOOST_NOEXCEPT
        {
            return thread::id(get_or_make_current_thread_data());
        }
@@ -454,22 +549,22 @@ namespace boost
                throw thread_interrupted();
            }
        }
-        
+
        bool interruption_enabled()
        {
            return get_current_thread_data() && get_current_thread_data()->interruption_enabled;
        }
-        
+
        bool interruption_requested()
        {
            return get_current_thread_data() && (detail::win32::WaitForSingleObject(get_current_thread_data()->interruption_handle,0)==0);
        }

-        void yield()
+        void yield() BOOST_NOEXCEPT
        {
            detail::win32::Sleep(0);
        }
-        
+
        disable_interruption::disable_interruption():
            interruption_was_enabled(interruption_enabled())
        {
@@ -478,7 +573,7 @@ namespace boost
                get_current_thread_data()->interruption_enabled=false;
            }
        }
-        
+
        disable_interruption::~disable_interruption()
        {
            if(get_current_thread_data())
@@ -494,7 +589,7 @@ namespace boost
                get_current_thread_data()->interruption_enabled=true;
            }
        }
-        
+
        restore_interruption::~restore_interruption()
        {
            if(get_current_thread_data())
@@ -510,8 +605,8 @@ namespace boost
        {
            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
            thread_exit_callback_node* const new_node=
-                heap_new<thread_exit_callback_node>(func,
-                                                    current_thread_data->thread_exit_callbacks);
+                heap_new<thread_exit_callback_node>(
+                    func,current_thread_data->thread_exit_callbacks);
            current_thread_data->thread_exit_callbacks=new_node;
        }

@@ -541,41 +636,43 @@ namespace boost
            }
            return NULL;
        }
-        
+
        void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing)
        {
-            tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in
            if(tss_data_node* const current_node=find_tss_data(key))
            {
-                if(cleanup_existing && current_node->func.get())
+                if(cleanup_existing && current_node->func.get() && current_node->value)
                {
                    (*current_node->func)(current_node->value);
                }
                current_node->func=func;
                current_node->value=tss_data;
            }
-            else
+            else if(func && tss_data)
            {
                detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-                tss_data_node* const new_node=heap_new<tss_data_node>(key,func,tss_data,current_thread_data->tss_data);
+                tss_data_node* const new_node=
+                    heap_new<tss_data_node>(key,func,tss_data,current_thread_data->tss_data);
                current_thread_data->tss_data=new_node;
            }
        }
    }
+    BOOST_THREAD_DECL void __cdecl on_process_enter()
+    {}
+
+    BOOST_THREAD_DECL void __cdecl on_thread_enter()
+    {}
+
+    BOOST_THREAD_DECL void __cdecl on_process_exit()
+    {
+        boost::cleanup_tls_key();
+    }
+
+    BOOST_THREAD_DECL void __cdecl on_thread_exit()
+    {
+        boost::run_thread_exit_callbacks();
+    }
+
 }


-extern "C" BOOST_THREAD_DECL void on_process_enter()
-{}
-
-extern "C" BOOST_THREAD_DECL void on_thread_enter()
-{}
-
-extern "C" BOOST_THREAD_DECL void on_process_exit()
-{}
-
-extern "C" BOOST_THREAD_DECL void on_thread_exit()
-{
-    boost::run_thread_exit_callbacks();
-}
-
--- a/src/win32/tss_dll.cpp
+++ b/src/win32/tss_dll.cpp
@@ -24,27 +24,27 @@
        {
            case DLL_PROCESS_ATTACH:
            {
-                on_process_enter();
-                on_thread_enter();
+                boost::on_process_enter();
+                boost::on_thread_enter();
                break;
            }

            case DLL_THREAD_ATTACH:
            {
-                on_thread_enter();
+                boost::on_thread_enter();
                break;
            }

            case DLL_THREAD_DETACH:
            {
-                on_thread_exit();
+                boost::on_thread_exit();
                break;
            }

            case DLL_PROCESS_DETACH:
            {
-                on_thread_exit();
-                on_process_exit();
+                boost::on_thread_exit();
+                boost::on_process_exit();
                break;
            }
        }
@@ -52,7 +52,9 @@
        return TRUE;
    }

-    extern "C" void tss_cleanup_implemented(void)
+namespace boost
+{
+    void tss_cleanup_implemented()
    {
        /*
        This function's sole purpose is to cause a link error in cases where
@@ -68,5 +70,7 @@
        longer needed and can be removed.
        */
    }
+}
+

 #endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)
--- a/src/win32/tss_pe.cpp
+++ b/src/win32/tss_pe.cpp
@@ -11,7 +11,7 @@

 #if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) 

-#if defined(__MINGW32__) && !defined(_WIN64)
+#if (defined(__MINGW32__) && !defined(_WIN64)) || defined(__MINGW64__)

 #include <boost/thread/detail/tss_hooks.hpp>

@@ -19,42 +19,37 @@

 #include <cstdlib>

-extern "C" void tss_cleanup_implemented(void) {}
+namespace boost
+{
+    void tss_cleanup_implemented() {}
+}

 namespace {
    void NTAPI on_tls_callback(void* h, DWORD dwReason, PVOID pv)
    {
        switch (dwReason)
        {
-            case DLL_THREAD_DETACH:
-            {
-                on_thread_exit();
-                break;
-            }
+        case DLL_THREAD_DETACH:
+        {
+            boost::on_thread_exit();
+            break;
+        }
        }
-    }
-
-    void on_after_ctors(void)
-    {
-        on_process_enter();
-    }
-    
-    void on_before_dtors(void)
-    {
-        on_thread_exit();
-    }
-    
-    void on_after_dtors(void)
-    {
-        on_process_exit();        
    }
 }

+#if defined(__MINGW64__) || (__MINGW32_MAJOR_VERSION >3) ||             \
+    ((__MINGW32_MAJOR_VERSION==3) && (__MINGW32_MINOR_VERSION>=18))
+extern "C"
+{
+    PIMAGE_TLS_CALLBACK __crt_xl_tls_callback__ __attribute__ ((section(".CRT$XLB"))) = on_tls_callback;
+}
+#else
 extern "C" {

-    void (* after_ctors )(void) __attribute__((section(".ctors")))     = on_after_ctors;
-    void (* before_dtors)(void) __attribute__((section(".dtors")))     = on_before_dtors;
-    void (* after_dtors )(void) __attribute__((section(".dtors.zzz"))) = on_after_dtors;
+    void (* after_ctors )() __attribute__((section(".ctors")))     = boost::on_process_enter;
+    void (* before_dtors)() __attribute__((section(".dtors")))     = boost::on_thread_exit;
+    void (* after_dtors )() __attribute__((section(".dtors.zzz"))) = boost::on_process_exit;

    ULONG __tls_index__ = 0;
    char __tls_end__ __attribute__((section(".tls$zzz"))) = 0;
@@ -62,10 +57,8 @@ extern "C" {


    PIMAGE_TLS_CALLBACK __crt_xl_start__ __attribute__ ((section(".CRT$XLA"))) = 0;
-    PIMAGE_TLS_CALLBACK __crt_xl_tls_callback__ __attribute__ ((section(".CRT$XLB"))) = on_tls_callback;
    PIMAGE_TLS_CALLBACK __crt_xl_end__ __attribute__ ((section(".CRT$XLZ"))) = 0;
 }
-
 extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata$T"))) =
 {
        (DWORD) &__tls_start__,
@@ -75,6 +68,7 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
        (DWORD) 0,
        (DWORD) 0
 };
+#endif


 #elif  defined(_MSC_VER) && !defined(UNDER_CE)
@@ -89,13 +83,13 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
    //Definitions required by implementation

    #if (_MSC_VER < 1300) // 1300 == VC++ 7.0
-        typedef void (__cdecl *_PVFV)(void);
+        typedef void (__cdecl *_PVFV)();
        #define INIRETSUCCESS
-        #define PVAPI void
+        #define PVAPI void __cdecl
    #else
-        typedef int (__cdecl *_PVFV)(void);
+        typedef int (__cdecl *_PVFV)();
        #define INIRETSUCCESS 0
-        #define PVAPI int
+        #define PVAPI int __cdecl
    #endif

    typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);
@@ -112,9 +106,9 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
    {
        //Forward declarations

-        static PVAPI on_tls_prepare(void);
-        static PVAPI on_process_init(void);
-        static PVAPI on_process_term(void);
+        static PVAPI on_tls_prepare();
+        static PVAPI on_process_init();
+        static PVAPI on_process_term();
        static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);

        //The .CRT$Xxx information is taken from Codeguru:
@@ -125,10 +119,10 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma section(".CRT$XCU",long,read)
 #pragma section(".CRT$XTU",long,read)
 #pragma section(".CRT$XLC",long,read)
-        static __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
-        static __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
-        static __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
-        static __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
+        __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
+        __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
+        __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
+        __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
 #else
        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
        #   pragma data_seg(push, old_seg)
@@ -168,7 +162,8 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma warning(push)
 #pragma warning(disable:4189)
 #endif
-        PVAPI on_tls_prepare(void)
+
+        PVAPI on_tls_prepare()
        {
            //The following line has an important side effect:
            //if the TLS directory is not already there, it will
@@ -209,7 +204,7 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma warning(pop)
 #endif

-        PVAPI on_process_init(void)
+        PVAPI on_process_init()
        {
            //Schedule on_thread_exit() to be called for the main
            //thread before destructors of global objects have been
@@ -220,18 +215,18 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
            //for destructors of global objects, so that
            //shouldn't be a problem.

-            atexit(on_thread_exit);
+            atexit(boost::on_thread_exit);

            //Call Boost process entry callback here

-            on_process_enter();
+            boost::on_process_enter();

            return INIRETSUCCESS;
        }

-        PVAPI on_process_term(void)
+        PVAPI on_process_term()
        {
-            on_process_exit();
+            boost::on_process_exit();
            return INIRETSUCCESS;
        }

@@ -239,16 +234,34 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
        {
            switch (dwReason)
            {
-                case DLL_THREAD_DETACH:
-                {
-                    on_thread_exit();
-                    break;
-                }
+            case DLL_THREAD_DETACH:
+                boost::on_thread_exit();
+                break;
            }
        }
+
+        BOOL WINAPI dll_callback(HANDLE, DWORD dwReason, LPVOID)
+        {
+            switch (dwReason)
+            {
+            case DLL_THREAD_DETACH:
+                boost::on_thread_exit();
+                break;
+            case DLL_PROCESS_DETACH:
+                boost::on_process_exit();
+                break;
+            }
+            return true;
+        }
    } //namespace

-    extern "C" void tss_cleanup_implemented(void)
+extern "C"
+{
+    extern BOOL (WINAPI * const _pRawDllMain)(HANDLE, DWORD, LPVOID)=&dll_callback;
+}
+namespace boost
+{
+    void tss_cleanup_implemented()
    {
        /*
        This function's sole purpose is to cause a link error in cases where
@@ -264,6 +277,8 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
        longer needed and can be removed.
        */
    }
+}
+
 #endif //defined(_MSC_VER) && !defined(UNDER_CE)

 #endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -1,6 +1,6 @@
-#  (C) Copyright William E. Kempf 2001. 
-#  (C) Copyright 2007 Anthony Williams. 
-#  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+#  (C) Copyright William E. Kempf 2001.
+#  (C) Copyright 2007 Anthony Williams.
+#  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)
 #
 # Boost.Threads test Jamfile
@@ -25,21 +25,46 @@ project

 rule thread-run ( sources )
 {
-    return 
+    return
    [ run $(sources) ../build//boost_thread ]
-    [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/<link>static 
+    [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/<link>static
        : : : : $(sources[1]:B)_lib ]
    ;
-}    
+}
+
+rule thread-run2 ( sources : name )
+{
+    return
+    [ run $(sources) ../build//boost_thread : : :
+      : $(name) ]
+    [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/<link>static
+        : : :
+      : $(name)_lib ]
+    ;
+}
+
+
+rule thread-compile-fail-V2 ( sources : reqs * : name )
+{
+    return
+    [ compile-fail $(sources)
+        : $(reqs)
+        : $(name) ]
+    ;
+}

 {
-    test-suite "threads"
-        : [ thread-run test_thread.cpp ]
+    test-suite threads
+    :
+          [ thread-run test_thread.cpp ]
          [ thread-run test_thread_id.cpp ]
          [ thread-run test_hardware_concurrency.cpp ]
          [ thread-run test_thread_move.cpp ]
+          [ thread-run test_thread_return_local.cpp ]
+          [ thread-run test_thread_move_return.cpp ]
          [ thread-run test_thread_launching.cpp ]
          [ thread-run test_thread_mf.cpp ]
+          [ thread-run test_thread_exit.cpp ]
          [ thread-run test_move_function.cpp ]
          [ thread-run test_mutex.cpp ]
          [ thread-run test_condition_notify_one.cpp ]
@@ -53,9 +78,282 @@ rule thread-run ( sources )
          [ thread-run test_shared_mutex.cpp ]
          [ thread-run test_shared_mutex_part_2.cpp ]
          [ thread-run test_shared_mutex_timed_locks.cpp ]
+          [ thread-run test_shared_mutex_timed_locks_chrono.cpp ]
+          #uncomment the following once these works on windows
+          #[ thread-run test_v2_shared_mutex.cpp ]
+          #[ thread-run test_v2_shared_mutex_part_2.cpp ]
+          #[ thread-run test_v2_shared_mutex_timed_locks.cpp ]
          [ thread-run test_lock_concept.cpp ]
          [ thread-run test_generic_locks.cpp ]
+          [ thread-run test_futures.cpp ]
          [ compile-fail no_implicit_move_from_lvalue_thread.cpp ]
          [ compile-fail no_implicit_assign_from_lvalue_thread.cpp ]
    ;
+
+
+    #explicit tickets ;
+    test-suite tickets
+    :
+          [ thread-run test_2309.cpp ]
+          [ thread-run test_2501.cpp ]
+          [ thread-run test_2741.cpp ]
+          [ thread-run test_4521.cpp ]
+          [ thread-run test_4648.cpp ]
+          [ thread-run test_4882.cpp ]
+          [ thread-run test_5542_1.cpp ]
+          [ thread-run test_5542_2.cpp ]
+          [ thread-run test_5542_3.cpp ]
+          [ thread-run test_5891.cpp ]
+          [ thread-run test_6130.cpp ]
+          [ thread-run test_6170.cpp ]
+          [ thread-run test_6174.cpp ]
+    ;
+
+
+    explicit oth_tickets ;
+    test-suite oth_tickets
+    :
+          [ thread-run test_5351.cpp ]
+          [ thread-run test_5502.cpp ]
+    ;
+
+
+
+    #explicit conditions ;
+    test-suite conditions
+    :
+          [ thread-compile-fail-V2 ./sync/conditions/condition_variable/assign_fail.cpp : : condition_variable__assign_f ]
+          [ thread-compile-fail-V2 ./sync/conditions/condition_variable/copy_fail.cpp : : condition_variable__copy_f ]
+          [ thread-run2 ./sync/conditions/condition_variable/default_pass.cpp : condition_variable__default_p ]
+          [ thread-run2 ./sync/conditions/condition_variable/dtor_pass.cpp : condition_variable__dtor_p ]
+          [ thread-run2 ./sync/conditions/condition_variable/native_handle_pass.cpp : condition_variable__native_handle_p ]
+          [ thread-run2 ./sync/conditions/condition_variable/wait_for_pass.cpp : condition_variable__wait_for_p ]
+          [ thread-run2 ./sync/conditions/condition_variable/wait_for_pred_pass.cpp : condition_variable__wait_for_pred_p ]
+          [ thread-run2 ./sync/conditions/condition_variable/wait_until_pass.cpp : condition_variable__wait_until_p ]
+          [ thread-run2 ./sync/conditions/condition_variable/wait_until_pred_pass.cpp : condition_variable__wait_until_pred_p ]
+
+          [ thread-compile-fail-V2 ./sync/conditions/condition_variable_any/assign_fail.cpp : : condition_variable_any__assign_f ]
+          [ thread-compile-fail-V2 ./sync/conditions/condition_variable_any/copy_fail.cpp : : condition_variable_any__copy_f ]
+          [ thread-run2 ./sync/conditions/condition_variable_any/default_pass.cpp : condition_variable_any__default_p ]
+          [ thread-run2 ./sync/conditions/condition_variable_any/dtor_pass.cpp : condition_variable_any__dtor_p ]
+          [ thread-run2 ./sync/conditions/condition_variable_any/wait_for_pass.cpp : condition_variable_any__wait_for_p ]
+          [ thread-run2 ./sync/conditions/condition_variable_any/wait_for_pred_pass.cpp : condition_variable_any__wait_for_pred_p ]
+          [ thread-run2 ./sync/conditions/condition_variable_any/wait_until_pass.cpp : condition_variable_any__wait_until_p ]
+          [ thread-run2 ./sync/conditions/condition_variable_any/wait_until_pred_pass.cpp : condition_variable_any__wait_until_pred_p ]
+          [ thread-run2 ./sync/conditions/cv_status/cv_status_pass.cpp : cv_status__cv_status_p ]
+    ;
+
+    #explicit futures ;
+    test-suite futures
+    :
+    #      [ thread-run2 ./sync/futures/async/async_pass.cpp : async__async_p ]
+          [ thread-compile-fail-V2 ./sync/futures/promise/copy_assign_fail.cpp : : promise__copy_assign_f ]
+          [ thread-run2 ./sync/futures/promise/default_pass.cpp : promise__default_p ]
+          [ thread-run2 ./sync/futures/promise/dtor_pass.cpp : promise__dtor_p ]
+          [ thread-run2 ./sync/futures/promise/get_future_pass.cpp : promise__get_future_p ]
+          [ thread-run2 ./sync/futures/promise/move_ctor_pass.cpp : promise__move_ctor_p ]
+          [ thread-run2 ./sync/futures/promise/move_assign_pass.cpp : promise__move_asign_p ]
+
+          [ thread-run2 ./sync/futures/future/share_pass.cpp : future__share_p ]
+
+    ;
+
+
+    #explicit mutual_exclusion ;
+    test-suite mutual_exclusion
+    :
+          #uncomment the following once these works on windows
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp : : lock_guard__cons__copy_assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp : : lock_guard__cons__copy_ctor_f ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp : lock_guard__cons__adopt_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/lock_guard/default_pass.cpp : lock_guard__cons__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/lock_guard/types_pass.cpp : lock_guard__types_p ]
+
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp : : unique_lock__cons__copy_assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp : : unique_lock__cons__copy_ctor_f ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp : unique_lock__cons__adopt_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp : unique_lock__cons__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp : unique_lock__cons__defer_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp : unique_lock__cons__duration_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp : unique_lock__cons__move_assign_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp : unique_lock__cons__move_ctor_p ]
+
+          #uncomment the following once these works on windows
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_pass.cpp : unique_lock__cons__move_ctor_upgrade_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_try_pass.cpp : unique_lock__cons__move_ctor_upgrade_lock_try_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_for_pass.cpp : unique_lock__cons__move_ctor_upgrade_lock_for_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_until_pass.cpp : unique_lock__cons__move_ctor_upgrade_lock_until_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp : unique_lock__cons__mutex_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp : unique_lock__cons__time_point_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp : unique_lock__cons__try_to_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp : unique_lock__lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp : unique_lock__try_lock_for_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp : unique_lock__try_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp : unique_lock__try_lock_until_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/unlock_pass.cpp : unique_lock__unlock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/member_swap_pass.cpp : unique_lock__member_swap_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/non_member_swap_pass.cpp : unique_lock__non_member_swap_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/release_pass.cpp : unique_lock__release_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/mutex_pass.cpp : unique_lock__mutex_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/op_bool_pass.cpp : unique_lock__op_bool_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/owns_lock_pass.cpp : unique_lock__owns_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/types_pass.cpp : unique_lock__types_p ]
+
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp : : shared_lock__cons__copy_assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp : : shared_lock__cons__copy_ctor_f ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp : shared_lock__cons__adopt_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp : shared_lock__cons__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp : shared_lock__cons__defer_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp : shared_lock__cons__duration_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp : shared_lock__cons__move_assign_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp : shared_lock__cons__move_ctor_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_unique_lock_pass.cpp : shared_lock__cons__move_ctor_unique_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_upgrade_lock_pass.cpp : shared_lock__cons__move_ctor_upgrade_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp : shared_lock__cons__mutex_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp : shared_lock__cons__time_point_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp : shared_lock__cons__try_to_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp : shared_lock__lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp : shared_lock__try_lock_for_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp : shared_lock__try_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp : shared_lock__try_lock_until_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp : shared_lock__unlock_p ]
+
+
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp : shared_lock__member_swap_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp : shared_lock__non_member_swap_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp : shared_lock__release_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp : shared_lock__mutex_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp : shared_lock__op_bool_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp : shared_lock__owns_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/types_pass.cpp : shared_lock__types_p ]
+
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/copy_assign_fail.cpp : : upgrade_lock__cons__copy_assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/copy_ctor_fail.cpp : : upgrade_lock__cons__copy_ctor_f ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/adopt_lock_pass.cpp : upgrade_lock__cons__adopt_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/default_pass.cpp : upgrade_lock__cons__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/defer_lock_pass.cpp : upgrade_lock__cons__defer_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp : upgrade_lock__cons__duration_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp : upgrade_lock__cons__move_assign_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_pass.cpp : upgrade_lock__cons__move_ctor_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_unique_lock_pass.cpp : upgrade_lock__cons__move_ctor_unique_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp : upgrade_lock__cons__mutex_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp : upgrade_lock__cons__time_point_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp : upgrade_lock__cons__try_to_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/lock_pass.cpp : upgrade_lock__lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_for_pass.cpp : upgrade_lock__try_lock_for_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_pass.cpp : upgrade_lock__try_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_until_pass.cpp : upgrade_lock__try_lock_until_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/unlock_pass.cpp : upgrade_lock__unlock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/member_swap_pass.cpp : upgrade_lock__member_swap_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/non_member_swap_pass.cpp : upgrade_lock__non_member_swap_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/release_pass.cpp : upgrade_lock__release_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/mutex_pass.cpp : upgrade_lock__mutex_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/op_bool_pass.cpp : upgrade_lock__op_bool_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/owns_lock_pass.cpp : upgrade_lock__owns_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp : upgrade_lock__types_p ]
+
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/mutex/assign_fail.cpp : : mutex__assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/mutex/copy_fail.cpp : : mutex__copy_f ]
+          [ thread-run2 ./sync/mutual_exclusion/mutex/default_pass.cpp : mutex__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/mutex/lock_pass.cpp : mutex__lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/mutex/native_handle_pass.cpp : mutex__native_handle_p ]
+          [ thread-run2 ./sync/mutual_exclusion/mutex/try_lock_pass.cpp : mutex__try_lock_p ]
+
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_mutex/assign_fail.cpp : : recursive_mutex__assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_mutex/copy_fail.cpp : : recursive_mutex__copy_f ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/default_pass.cpp : recursive_mutex__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/lock_pass.cpp : recursive_mutex__lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/native_handle_pass.cpp : recursive_mutex__native_handle_p ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp : recursive_mutex__try_lock_p ]
+
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_timed_mutex/assign_fail.cpp : : recursive_timed_mutex__assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_timed_mutex/copy_fail.cpp : : recursive_timed_mutex__copy_f ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/default_pass.cpp : recursive_timed_mutex__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp : recursive_timed_mutex__lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/native_handle_pass.cpp : recursive_timed_mutex__native_handle_p ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp : recursive_timed_mutex__try_lock_for_p ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp : recursive_timed_mutex__try_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp : recursive_timed_mutex__try_lock_until_p ]
+
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/timed_mutex/assign_fail.cpp : : timed_mutex__assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/timed_mutex/copy_fail.cpp : : timed_mutex__copy_f ]
+          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/default_pass.cpp : timed_mutex__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/lock_pass.cpp : timed_mutex__lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/native_handle_pass.cpp : timed_mutex__native_handle_p ]
+          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp : timed_mutex__try_lock_for_p ]
+          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp : timed_mutex__try_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp : timed_mutex__try_lock_until_p ]
+
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/shared_mutex/assign_fail.cpp : : shared_mutex__assign_f ]
+          [ thread-compile-fail-V2 ./sync/mutual_exclusion/shared_mutex/copy_fail.cpp : : shared_mutex__copy_f ]
+          [ thread-run2 ./sync/mutual_exclusion/shared_mutex/default_pass.cpp : shared_mutex__default_p ]
+          [ thread-run2 ./sync/mutual_exclusion/shared_mutex/lock_pass.cpp : shared_mutex__lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp : shared_mutex__try_lock_for_p ]
+          [ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp : shared_mutex__try_lock_p ]
+          [ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp : shared_mutex__try_lock_until_p ]
+
+    ;
+
+    #explicit this_thread ;
+    test-suite this_thread
+    :
+          [ thread-run2 ./threads/this_thread/get_id/get_id_pass.cpp : this_thread__get_id_p ]
+          [ thread-run2 ./threads/this_thread/sleep_for/sleep_for_pass.cpp : this_thread__sleep_for_p ]
+          [ thread-run2 ./threads/this_thread/sleep_until/sleep_until_pass.cpp : this_thread__sleep_until_p ]
+    ;
+
+    #explicit thread ;
+    test-suite thread
+    :
+          [ thread-compile-fail-V2 ./threads/thread/assign/copy_fail.cpp : : thread__assign__copy_f ]
+          [ thread-run2 ./threads/thread/assign/move_pass.cpp : thread__assign__move_p ]
+          [ thread-compile-fail-V2 ./threads/thread/constr/copy_fail.cpp : : thread__constr__copy_f ]
+          [ thread-run2 ./threads/thread/constr/default_pass.cpp : thread__constr__default_p ]
+          [ thread-run2 ./threads/thread/constr/F_pass.cpp : thread__constr__F_p ]
+          [ thread-run2 ./threads/thread/constr/Frvalue_pass.cpp : thread__constr__Frvalue_p ]
+          #[ thread-run2 ./threads/thread/constr/FrvalueArgs_pass.cpp : thread__constr__FrvalueArgs_p ]
+          [ thread-run2 ./threads/thread/constr/move_pass.cpp : thread__constr__move_p ]
+          [ thread-run2 ./threads/thread/destr/dtor_pass.cpp : thread__destr__dtor_p ]
+          [ thread-run2 ./threads/thread/id/hash_pass.cpp : thread__id__hash_p ]
+          [ thread-run2 ./threads/thread/members/detach_pass.cpp : thread__detach_p ]
+          [ thread-run2 ./threads/thread/members/get_id_pass.cpp : thread__get_id_p ]
+          [ thread-run2 ./threads/thread/members/join_pass.cpp : thread__join_p ]
+          [ thread-run2 ./threads/thread/members/joinable_pass.cpp : thread__joinable_p ]
+          [ thread-run2 ./threads/thread/members/native_handle_pass.cpp : thread__native_handle_p ]
+          [ thread-run2 ./threads/thread/members/swap_pass.cpp : thread__swap_p ]
+          [ thread-run2 ./threads/thread/non_members/swap_pass.cpp : swap_threads_p ]
+          [ thread-run2 ./threads/thread/static/hardware_concurrency_pass.cpp : thread__hardware_concurrency_p ]
+    ;
+
+    explicit examples ;
+    test-suite examples
+    :
+          [ thread-run ../example/monitor.cpp ]
+          #[ thread-run ../example/starvephil.cpp ]
+          #[ thread-run ../example/tennis.cpp ]
+          #[ thread-run ../example/condition.cpp ]
+          [ thread-run ../example/mutex.cpp ]
+          [ thread-run ../example/once.cpp ]
+          [ thread-run ../example/recursive_mutex.cpp ]
+          [ thread-run2 ../example/thread.cpp : ex_thread ]
+          [ thread-run ../example/thread_group.cpp ]
+          [ thread-run ../example/tss.cpp ]
+          [ thread-run ../example/xtime.cpp ]
+          [ thread-run ../example/shared_monitor.cpp ]
+          #[ thread-run ../example/shared_mutex.cpp ]
+          #[ thread-run ../example/v2_shared_monitor.cpp ]
+          #[ thread-run ../example/v2_shared_mutex.cpp ]
+    ;
+
+    #explicit shared_upwards ;
+    #test-suite shared_upwards
+    #:
+    #      [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_try_pass.cpp : unique_lock__cons__move_ctor_shared_lock_try_p ]
+    #      [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_for_pass.cpp : unique_lock__cons__move_ctor_shared_lock_for_p ]
+    #      [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_until_pass.cpp : unique_lock__cons__move_ctor_shared_lock_until_p ]
+    #
+    #      [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_try_pass.cpp : upgrade_lock__cons__move_ctor_shared_lock_try_p ]
+    #      [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_for_pass.cpp : upgrade_lock__cons__move_ctor_shared_lock_for_p ]
+    #      [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_until_pass.cpp : upgrade_lock__cons__move_ctor_shared_lock_until_p ]
+    #;
 }
--- a/test/sync/conditions/condition_variable/assign_fail.cpp
+++ b/test/sync/conditions/condition_variable/assign_fail.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable& operator=(const condition_variable&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+
+int fail()
+{
+  boost::condition_variable cv0;
+  boost::condition_variable cv1;
+  cv1 = cv0;
+}
+
--- a/test/sync/conditions/condition_variable/copy_fail.cpp
+++ b/test/sync/conditions/condition_variable/copy_fail.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable(const condition_variable&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int fail()
+{
+  boost::condition_variable cv0;
+  boost::condition_variable cv1(cv0);
+}
+
--- a/test/sync/conditions/condition_variable/default_pass.cpp
+++ b/test/sync/conditions/condition_variable/default_pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable(const condition_variable&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+  boost::condition_variable cv0;
+  return boost::report_errors();
+}
+
--- a/test/sync/conditions/condition_variable/dtor_pass.cpp
+++ b/test/sync/conditions/condition_variable/dtor_pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable(const condition_variable&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::condition_variable* cv;
+boost::mutex m;
+typedef boost::unique_lock<boost::mutex> Lock;
+
+bool f_ready = false;
+bool g_ready = false;
+
+void f()
+{
+  Lock lk(m);
+  f_ready = true;
+  cv->notify_one();
+  cv->wait(lk);
+  delete cv;
+}
+
+void g()
+{
+  Lock lk(m);
+  g_ready = true;
+  cv->notify_one();
+  while (!f_ready)
+  {
+    cv->wait(lk);
+  }
+  cv->notify_one();
+}
+
+int main()
+{
+  cv = new boost::condition_variable;
+  boost::thread th2(g);
+  Lock lk(m);
+  while (!g_ready)
+  {
+    cv->wait(lk);
+  }
+  lk.unlock();
+  boost::thread th1(f);
+  th1.join();
+  th2.join();
+  return boost::report_errors();
+}
+
--- a/test/sync/conditions/condition_variable/native_handle_pass.cpp
+++ b/test/sync/conditions/condition_variable/native_handle_pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable(const condition_variable&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+#if defined BOOST_THREAD_DEFINES_CONDITION_VARIABLE_NATIVE_HANDLE
+  //BOOST_STATIC_ASSERT((boost::is_same<boost::condition_variable::native_handle_type, pthread_cond_t*>::value));
+  boost::condition_variable cv;
+  boost::condition_variable::native_handle_type h = cv.native_handle();
+  BOOST_TEST(h != 0);
+#else
+#error "Test not applicable: BOOST_THREAD_DEFINES_CONDITION_VARIABLE_NATIVE_HANDLE not defined for this platform as not supported"
+#endif
+  return boost::report_errors();
+}
+
--- a/test/sync/conditions/condition_variable/wait_for_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_for_pass.cpp
@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable(const condition_variable&) = delete;
+
+#include <iostream>
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined BOOST_THREAD_USES_CHRONO
+
+boost::condition_variable cv;
+boost::mutex mut;
+
+int test1 = 0;
+int test2 = 0;
+
+int runs = 0;
+
+void f()
+{
+  typedef boost::chrono::steady_clock Clock;
+  typedef boost::chrono::milliseconds milliseconds;
+  boost::unique_lock<boost::mutex> lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  int count=0;
+  while (test2 == 0 && cv.wait_for(lk, milliseconds(250)) == boost::cv_status::no_timeout)
+    count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < milliseconds(250));
+    BOOST_TEST(test2 != 0);
+  }
+  else
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 - milliseconds(250) < milliseconds(count*250+5+1000));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
+}
+
+int main()
+{
+  {
+    boost::unique_lock<boost::mutex> lk(mut);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    test2 = 1;
+    lk.unlock();
+    cv.notify_one();
+    t.join();
+  }
+  test1 = 0;
+  test2 = 0;
+  {
+    boost::unique_lock<boost::mutex> lk(mut);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    lk.unlock();
+    t.join();
+  }
+
+  return boost::report_errors();
+}
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif
+
--- a/test/sync/conditions/condition_variable/wait_for_pred_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_for_pred_pass.cpp
@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable(const condition_variable&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined BOOST_THREAD_USES_CHRONO
+
+class Pred
+{
+  int& i_;
+public:
+  explicit Pred(int& i) :
+    i_(i)
+  {
+  }
+
+  bool operator()()
+  {
+    return i_ != 0;
+  }
+};
+
+boost::condition_variable cv;
+boost::mutex mut;
+
+int test1 = 0;
+int test2 = 0;
+
+int runs = 0;
+
+void f()
+{
+  typedef boost::chrono::system_clock Clock;
+  typedef boost::chrono::milliseconds milliseconds;
+  boost::unique_lock < boost::mutex > lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  int count=0;
+  bool r = cv.wait_for(lk, milliseconds(250), Pred(test2));
+  count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 < milliseconds(250+1000));
+    BOOST_TEST(test2 != 0);
+  }
+  else
+  {
+    BOOST_TEST(t1 - t0 - milliseconds(250) < milliseconds(count*250+2));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
+}
+
+int main()
+{
+  {
+    boost::unique_lock < boost::mutex > lk(mut);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    test2 = 1;
+    lk.unlock();
+    cv.notify_one();
+    t.join();
+  }
+  test1 = 0;
+  test2 = 0;
+  {
+    boost::unique_lock < boost::mutex > lk(mut);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    lk.unlock();
+    t.join();
+  }
+
+  return boost::report_errors();
+}
+
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif
--- a/test/sync/conditions/condition_variable/wait_until_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_until_pass.cpp
@@ -0,0 +1,108 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable(const condition_variable&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined BOOST_THREAD_USES_CHRONO
+
+struct Clock
+{
+  typedef boost::chrono::milliseconds duration;
+  typedef duration::rep rep;
+  typedef duration::period period;
+  typedef boost::chrono::time_point<Clock> time_point;
+  static const bool is_steady = true;
+
+  static time_point now()
+  {
+    using namespace boost::chrono;
+    return time_point(duration_cast<duration> (steady_clock::now().time_since_epoch()));
+  }
+};
+
+boost::condition_variable cv;
+boost::mutex mut;
+
+int test1 = 0;
+int test2 = 0;
+
+int runs = 0;
+
+void f()
+{
+  boost::unique_lock < boost::mutex > lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  Clock::time_point t = t0 + Clock::duration(250);
+  int count=0;
+  while (test2 == 0 && cv.wait_until(lk, t) == boost::cv_status::no_timeout)
+    count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < Clock::duration(250));
+    BOOST_TEST(test2 != 0);
+  }
+  else
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 - Clock::duration(250) < Clock::duration(count*250+5+1000));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
+}
+
+int main()
+{
+  {
+    boost::unique_lock < boost::mutex > lk(mut);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    test2 = 1;
+    lk.unlock();
+    cv.notify_one();
+    t.join();
+  }
+  test1 = 0;
+  test2 = 0;
+  {
+    boost::unique_lock < boost::mutex > lk(mut);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    lk.unlock();
+    t.join();
+  }
+
+  return boost::report_errors();
+}
+
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif
--- a/test/sync/conditions/condition_variable/wait_until_pred_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_until_pred_pass.cpp
@@ -0,0 +1,122 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable>
+
+// class condition_variable;
+
+// condition_variable(const condition_variable&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined BOOST_THREAD_USES_CHRONO
+
+struct Clock
+{
+  typedef boost::chrono::milliseconds duration;
+  typedef duration::rep rep;
+  typedef duration::period period;
+  typedef boost::chrono::time_point<Clock> time_point;
+  static const bool is_steady = true;
+
+  static time_point now()
+  {
+    using namespace boost::chrono;
+    return time_point(duration_cast<duration> (steady_clock::now().time_since_epoch()));
+  }
+};
+
+class Pred
+{
+  int& i_;
+public:
+  explicit Pred(int& i) :
+    i_(i)
+  {
+  }
+
+  bool operator()()
+  {
+    return i_ != 0;
+  }
+};
+
+boost::condition_variable cv;
+boost::mutex mut;
+
+int test1 = 0;
+int test2 = 0;
+
+int runs = 0;
+
+void f()
+{
+  boost::unique_lock<boost::mutex> lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  Clock::time_point t = t0 + Clock::duration(250);
+  bool r = cv.wait_until(lk, t, Pred(test2));
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < Clock::duration(250));
+    BOOST_TEST(test2 != 0);
+    BOOST_TEST(r);
+  }
+  else
+  {
+    BOOST_TEST(t1 - t0 - Clock::duration(250) < Clock::duration(250+2));
+    BOOST_TEST(test2 == 0);
+    BOOST_TEST(!r);
+  }
+  ++runs;
+}
+
+int main()
+{
+  {
+    boost::unique_lock<boost::mutex> lk(mut);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    test2 = 1;
+    lk.unlock();
+    cv.notify_one();
+    t.join();
+  }
+  test1 = 0;
+  test2 = 0;
+  {
+    boost::unique_lock<boost::mutex> lk(mut);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    lk.unlock();
+    t.join();
+  }
+
+  return boost::report_errors();
+}
+
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif
--- a/test/sync/conditions/condition_variable_any/assign_fail.cpp
+++ b/test/sync/conditions/condition_variable_any/assign_fail.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable_any>
+
+// class condition_variable_any;
+
+// condition_variable_any& operator=(const condition_variable_any&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+
+int fail()
+{
+  boost::condition_variable_any cv0;
+  boost::condition_variable_any cv1;
+  cv1 = cv0;
+}
+
--- a/test/sync/conditions/condition_variable_any/copy_fail.cpp
+++ b/test/sync/conditions/condition_variable_any/copy_fail.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable_any>
+
+// class condition_variable_any;
+
+// condition_variable_any(const condition_variable_any&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int fail()
+{
+  boost::condition_variable_any cv0;
+  boost::condition_variable_any cv1(cv0);
+}
+
--- a/test/sync/conditions/condition_variable_any/default_pass.cpp
+++ b/test/sync/conditions/condition_variable_any/default_pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable_any>
+
+// class condition_variable_any;
+
+// condition_variable_any(const condition_variable_any&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+  boost::condition_variable_any cv0;
+  return boost::report_errors();
+}
+
--- a/test/sync/conditions/condition_variable_any/dtor_pass.cpp
+++ b/test/sync/conditions/condition_variable_any/dtor_pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable_any>
+
+// class condition_variable_any;
+
+// condition_variable_any(const condition_variable_any&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::condition_variable_any* cv;
+boost::timed_mutex m;
+typedef boost::unique_lock<boost::timed_mutex> Lock;
+
+bool f_ready = false;
+bool g_ready = false;
+
+void f()
+{
+  Lock lk(m);
+  f_ready = true;
+  cv->notify_one();
+  cv->wait(lk);
+  delete cv;
+}
+
+void g()
+{
+  Lock lk(m);
+  g_ready = true;
+  cv->notify_one();
+  while (!f_ready)
+  {
+    cv->wait(lk);
+  }
+  cv->notify_one();
+}
+
+int main()
+{
+  cv = new boost::condition_variable_any;
+  boost::thread th2(g);
+  Lock lk(m);
+  while (!g_ready)
+  {
+    cv->wait(lk);
+  }
+  lk.unlock();
+  boost::thread th1(f);
+  th1.join();
+  th2.join();
+  return boost::report_errors();
+}
+
--- a/test/sync/conditions/condition_variable_any/wait_for_pass.cpp
+++ b/test/sync/conditions/condition_variable_any/wait_for_pass.cpp
@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable_any>
+
+// class condition_variable_any;
+
+// condition_variable_any(const condition_variable_any&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined BOOST_THREAD_USES_CHRONO
+
+boost::condition_variable_any cv;
+
+typedef boost::timed_mutex L0;
+typedef boost::unique_lock<L0> L1;
+
+L0 m0;
+
+int test1 = 0;
+int test2 = 0;
+
+int runs = 0;
+
+void f()
+{
+    typedef boost::chrono::system_clock Clock;
+    typedef boost::chrono::milliseconds milliseconds;
+    L1 lk(m0);
+    BOOST_TEST(test2 == 0);
+    test1 = 1;
+    cv.notify_one();
+    int count=0;
+    Clock::time_point t0 = Clock::now();
+    while (test2 == 0 &&
+           cv.wait_for(lk, milliseconds(250)) == boost::cv_status::no_timeout)
+        count++;
+    Clock::time_point t1 = Clock::now();
+    if (runs == 0)
+    {
+        BOOST_TEST(t1 - t0 < milliseconds(250));
+        BOOST_TEST(test2 != 0);
+    }
+    else
+    {
+      // This test is spurious as it depends on the time the thread system switches the threads
+        BOOST_TEST(t1 - t0 - milliseconds(250) < milliseconds(count*250+5+1000));
+        BOOST_TEST(test2 == 0);
+    }
+    ++runs;
+}
+
+int main()
+{
+    {
+        L1 lk(m0);
+        boost::thread t(f);
+        BOOST_TEST(test1 == 0);
+        while (test1 == 0)
+            cv.wait(lk);
+        BOOST_TEST(test1 != 0);
+        test2 = 1;
+        lk.unlock();
+        cv.notify_one();
+        t.join();
+    }
+    test1 = 0;
+    test2 = 0;
+    {
+        L1 lk(m0);
+        boost::thread t(f);
+        BOOST_TEST(test1 == 0);
+        while (test1 == 0)
+            cv.wait(lk);
+        BOOST_TEST(test1 != 0);
+        lk.unlock();
+        t.join();
+    }
+
+  return boost::report_errors();
+}
+
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif
--- a/test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp
+++ b/test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp
@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable_any>
+
+// class condition_variable_any;
+
+// condition_variable_any(const condition_variable_any&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined BOOST_THREAD_USES_CHRONO
+
+class Pred
+{
+  int& i_;
+public:
+  explicit Pred(int& i) :
+    i_(i)
+  {
+  }
+
+  bool operator()()
+  {
+    return i_ != 0;
+  }
+};
+
+boost::condition_variable_any cv;
+
+typedef boost::timed_mutex L0;
+typedef boost::unique_lock<L0> L1;
+
+L0 m0;
+
+int test1 = 0;
+int test2 = 0;
+
+int runs = 0;
+
+void f()
+{
+  typedef boost::chrono::system_clock Clock;
+  typedef boost::chrono::milliseconds milliseconds;
+  L1 lk(m0);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  bool r = cv.wait_for(lk, milliseconds(250), Pred(test2));
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < milliseconds(250));
+    BOOST_TEST(test2 != 0);
+  }
+  else
+  {
+    BOOST_TEST(t1 - t0 - milliseconds(250) < milliseconds(250+5));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
+}
+
+int main()
+{
+  {
+    L1 lk(m0);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    test2 = 1;
+    lk.unlock();
+    cv.notify_one();
+    t.join();
+  }
+  test1 = 0;
+  test2 = 0;
+  {
+    L1 lk(m0);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    lk.unlock();
+    t.join();
+  }
+
+  return boost::report_errors();
+}
+
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif
--- a/test/sync/conditions/condition_variable_any/wait_until_pass.cpp
+++ b/test/sync/conditions/condition_variable_any/wait_until_pass.cpp
@@ -0,0 +1,112 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable_any>
+
+// class condition_variable_any;
+
+// condition_variable_any(const condition_variable_any&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined BOOST_THREAD_USES_CHRONO
+
+struct Clock
+{
+  typedef boost::chrono::milliseconds duration;
+  typedef duration::rep rep;
+  typedef duration::period period;
+  typedef boost::chrono::time_point<Clock> time_point;
+  static const bool is_steady = true;
+
+  static time_point now()
+  {
+    using namespace boost::chrono;
+    return time_point(duration_cast<duration> (steady_clock::now().time_since_epoch()));
+  }
+};
+
+boost::condition_variable_any cv;
+
+typedef boost::timed_mutex L0;
+typedef boost::unique_lock<L0> L1;
+
+L0 m0;
+
+int test1 = 0;
+int test2 = 0;
+
+int runs = 0;
+
+void f()
+{
+  L1 lk(m0);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  Clock::time_point t = t0 + Clock::duration(250);
+  int count=0;
+  while (test2 == 0 && cv.wait_until(lk, t) == boost::cv_status::no_timeout)
+    count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < Clock::duration(250));
+    BOOST_TEST(test2 != 0);
+  }
+  else
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 - Clock::duration(250) < Clock::duration(250*count+5+1000));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
+}
+
+int main()
+{
+  {
+    L1 lk(m0);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    test2 = 1;
+    lk.unlock();
+    cv.notify_one();
+    t.join();
+  }
+  test1 = 0;
+  test2 = 0;
+  {
+    L1 lk(m0);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    lk.unlock();
+    t.join();
+  }
+
+  return boost::report_errors();
+}
+
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif
--- a/test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp
+++ b/test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp
@@ -0,0 +1,126 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/condition_variable_any>
+
+// class condition_variable_any;
+
+// condition_variable_any(const condition_variable_any&) = delete;
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined BOOST_THREAD_USES_CHRONO
+
+struct Clock
+{
+  typedef boost::chrono::milliseconds duration;
+  typedef duration::rep rep;
+  typedef duration::period period;
+  typedef boost::chrono::time_point<Clock> time_point;
+  static const bool is_steady = true;
+
+  static time_point now()
+  {
+    using namespace boost::chrono;
+    return time_point(duration_cast<duration> (steady_clock::now().time_since_epoch()));
+  }
+};
+
+class Pred
+{
+  int& i_;
+public:
+  explicit Pred(int& i) :
+    i_(i)
+  {
+  }
+
+  bool operator()()
+  {
+    return i_ != 0;
+  }
+};
+
+boost::condition_variable_any cv;
+
+typedef boost::timed_mutex L0;
+typedef boost::unique_lock<L0> L1;
+
+L0 m0;
+
+int test1 = 0;
+int test2 = 0;
+
+int runs = 0;
+
+void f()
+{
+  L1 lk(m0);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  Clock::time_point t = t0 + Clock::duration(250);
+  bool r = cv.wait_until(lk, t, Pred(test2));
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < Clock::duration(250));
+    BOOST_TEST(test2 != 0);
+    BOOST_TEST(r);
+  }
+  else
+  {
+    BOOST_TEST(t1 - t0 - Clock::duration(250) < Clock::duration(250+2));
+    BOOST_TEST(test2 == 0);
+    BOOST_TEST(!r);
+  }
+  ++runs;
+}
+
+int main()
+{
+  {
+    L1 lk(m0);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    test2 = 1;
+    lk.unlock();
+    cv.notify_one();
+    t.join();
+  }
+  test1 = 0;
+  test2 = 0;
+  {
+    L1 lk(m0);
+    boost::thread t(f);
+    BOOST_TEST(test1 == 0);
+    while (test1 == 0)
+      cv.wait(lk);
+    BOOST_TEST(test1 != 0);
+    lk.unlock();
+    t.join();
+  }
+
+  return boost::report_errors();
+}
+
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif
--- a/test/sync/conditions/cv_status/cv_status_pass.cpp
+++ b/test/sync/conditions/cv_status/cv_status_pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Copyright (C) 2011 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)
+
+// <boost/thread/thread.hpp>
+
+// class thread
+
+// static unsigned hardware_concurrency();
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+  {
+    BOOST_TEST(boost::cv_status::no_timeout != boost::cv_status::timeout);
+  }
+  {
+    boost::cv_status st = boost::cv_status::no_timeout;
+    BOOST_TEST(st == boost::cv_status::no_timeout);
+    BOOST_TEST(boost::cv_status::no_timeout==st);
+    BOOST_TEST(st != boost::cv_status::timeout);
+    BOOST_TEST(boost::cv_status::timeout!=st);
+  }
+  {
+    boost::cv_status st = boost::cv_status::timeout;
+    BOOST_TEST(st == boost::cv_status::timeout);
+    BOOST_TEST(boost::cv_status::timeout==st);
+    BOOST_TEST(st != boost::cv_status::no_timeout);
+    BOOST_TEST(boost::cv_status::no_timeout!=st);
+  }
+  {
+    boost::cv_status st;
+    st = boost::cv_status::no_timeout;
+    BOOST_TEST(st == boost::cv_status::no_timeout);
+    BOOST_TEST(boost::cv_status::no_timeout==st);
+    BOOST_TEST(st != boost::cv_status::timeout);
+    BOOST_TEST(boost::cv_status::timeout!=st);
+  }
+  {
+    boost::cv_status st;
+    st = boost::cv_status::timeout;
+    BOOST_TEST(st == boost::cv_status::timeout);
+    BOOST_TEST(boost::cv_status::timeout==st);
+    BOOST_TEST(st != boost::cv_status::no_timeout);
+    BOOST_TEST(boost::cv_status::no_timeout!=st);
+  }
+  return boost::report_errors();
+}
+
--- a/test/sync/futures/async/async_pass.cpp
+++ b/test/sync/futures/async/async_pass.cpp
@@ -0,0 +1,184 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <boost/thread/future.hpp>
+
+// template <class F, class... Args>
+//     future<typename result_of<F(Args...)>::type>
+//     async(F&& f, Args&&... args);
+
+// template <class F, class... Args>
+//     future<typename result_of<F(Args...)>::type>
+//     async(launch policy, F&& f, Args&&... args);
+
+
+#include <boost/thread/future.hpp>
+#include <memory>
+#include <boost/detail/lightweight_test.hpp>
+
+typedef boost::chrono::high_resolution_clock Clock;
+typedef boost::chrono::milliseconds ms;
+
+int f0()
+{
+  boost::this_thread::sleep_for(ms(200));
+  return 3;
+}
+
+int i = 0;
+
+int& f1()
+{
+  boost::this_thread::sleep_for(ms(200));
+  return i;
+}
+
+void f2()
+{
+  boost::this_thread::sleep_for(ms(200));
+}
+
+boost::unique_ptr<int> f3(int i)
+{
+  boost::this_thread::sleep_for(ms(200));
+  return boost::unique_ptr<int>(new int(i));
+}
+
+boost::unique_ptr<int> f4(boost::unique_ptr<int>&& p)
+{
+  boost::this_thread::sleep_for(ms(200));
+  return boost::move(p);
+}
+
+int main()
+{
+  {
+    boost::future<int> f = boost::async(f0);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(f.get() == 3);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<int> f = boost::async(boost::launch::async, f0);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(f.get() == 3);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<int> f = boost::async(boost::launch::any, f0);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(f.get() == 3);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<int> f = boost::async(boost::launch::deferred, f0);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(f.get() == 3);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 > ms(100));
+  }
+
+  {
+    boost::future<int&> f = boost::async(f1);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(&f.get() == &i);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<int&> f = boost::async(boost::launch::async, f1);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(&f.get() == &i);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<int&> f = boost::async(boost::launch::any, f1);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(&f.get() == &i);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<int&> f = boost::async(boost::launch::deferred, f1);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(&f.get() == &i);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 > ms(100));
+  }
+
+  {
+    boost::future<void> f = boost::async(f2);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    f.get();
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<void> f = boost::async(boost::launch::async, f2);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    f.get();
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<void> f = boost::async(boost::launch::any, f2);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    f.get();
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  {
+    boost::future<void> f = boost::async(boost::launch::deferred, f2);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    f.get();
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 > ms(100));
+  }
+
+  {
+    boost::future<boost::unique_ptr<int>> f = boost::async(f3, 3);
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(*f.get() == 3);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+
+  {
+    boost::future<boost::unique_ptr<int>> f = boost::async(f4, boost::unique_ptr<int>(new int(3)));
+    boost::this_thread::sleep_for(ms(300));
+    Clock::time_point t0 = Clock::now();
+    BOOST_TEST(*f.get() == 3);
+    Clock::time_point t1 = Clock::now();
+    BOOST_TEST(t1 - t0 < ms(100));
+  }
+  return boost::report_errors();
+}
+
--- a/test/sync/futures/future/share_pass.cpp
+++ b/test/sync/futures/future/share_pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <boost/thread/future.hpp>
+
+// class future<R>
+
+// shared_future<R> share() &&;
+
+#define BOOST_THREAD_VERSION 2
+
+#include <boost/thread/future.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+
+  {
+      typedef int T;
+      boost::promise<T> p;
+      boost::future<T> f0 = p.get_future();
+      boost::shared_future<T> sf = f0.share();
+      boost::shared_future<T> f = sf;
+      BOOST_TEST(!f0.valid());
+      BOOST_TEST(f.valid());
+  }
+  {
+      typedef int T;
+      boost::future<T> f0;
+      boost::shared_future<T> sf = f0.share();
+      boost::shared_future<T> f = sf;
+      BOOST_TEST(!f0.valid());
+      BOOST_TEST(!f.valid());
+  }
+  {
+      typedef int& T;
+      boost::promise<T> p;
+      boost::future<T> f0 = p.get_future();
+      boost::shared_future<T> sf = f0.share();
+      boost::shared_future<T> f = sf;
+      BOOST_TEST(!f0.valid());
+      BOOST_TEST(f.valid());
+  }
+  {
+      typedef int& T;
+      boost::future<T> f0;
+      boost::shared_future<T> sf = f0.share();
+      boost::shared_future<T> f = sf;
+      BOOST_TEST(!f0.valid());
+      BOOST_TEST(!f.valid());
+  }
+  {
+      typedef void T;
+      boost::promise<T> p;
+      boost::future<T> f0 = p.get_future();
+      boost::shared_future<T> sf = f0.share();
+      boost::shared_future<T> f = sf;
+      BOOST_TEST(!f0.valid());
+      BOOST_TEST(f.valid());
+  }
+  {
+      typedef void T;
+      boost::future<T> f0;
+      boost::shared_future<T> sf = f0.share();
+      boost::shared_future<T> f = sf;
+      BOOST_TEST(!f0.valid());
+      BOOST_TEST(!f.valid());
+  }
+
+
+  return boost::report_errors();
+}
+
--- a/test/sync/futures/promise/copy_assign_fail.cpp
+++ b/test/sync/futures/promise/copy_assign_fail.cpp
@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <boost/thread/future.hpp>
+// class promise<R>
+// promise& operator=(const promise& rhs) = delete;
+
+#define BOOST_THREAD_VERSION 2
+#include <boost/thread/future.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+
+  //BOOST_TEST(test_alloc_base::count == 0);
+  {
+    //boost::promise<int> p0(boost::allocator_arg, test_allocator<int>());
+    //boost::promise<int> p(boost::allocator_arg, test_allocator<int>());
+    boost::promise<int> p0;
+    boost::promise<int> p;
+    //BOOST_TEST(test_alloc_base::count == 2);
+    p = p0;
+    //BOOST_TEST(test_alloc_base::count == 1);
+    boost::future<int> f = p.get_future();
+    //BOOST_TEST(test_alloc_base::count == 1);
+    BOOST_TEST(f.valid());
+    try
+    {
+      f = p0.get_future();
+      BOOST_TEST(false);
+    }
+    catch (const boost::future_error& e)
+    {
+      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+    }
+    //BOOST_TEST(test_alloc_base::count == 1);
+  }
+  //BOOST_TEST(test_alloc_base::count == 0);
+//  {
+//    //boost::promise<int&> p0(boost::allocator_arg, test_allocator<int>());
+//    //boost::promise<int&> p(boost::allocator_arg, test_allocator<int>());
+//    boost::promise<int&> p0;
+//    boost::promise<int&> p;
+//    //BOOST_TEST(test_alloc_base::count == 2);
+//    p = p0;
+//    //BOOST_TEST(test_alloc_base::count == 1);
+//    boost::future<int&> f = p.get_future();
+//    //BOOST_TEST(test_alloc_base::count == 1);
+//    BOOST_TEST(f.valid());
+//    try
+//    {
+//      f = p0.get_future();
+//      BOOST_TEST(false);
+//    }
+//    catch (const boost::future_error& e)
+//    {
+//      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+//    }
+//    //BOOST_TEST(test_alloc_base::count == 1);
+//  }
+//  //BOOST_TEST(test_alloc_base::count == 0);
+//  {
+//    //boost::promise<void> p0(boost::allocator_arg, test_allocator<void>());
+//    //boost::promise<void> p(boost::allocator_arg, test_allocator<void>());
+//    boost::promise<void> p0;
+//    boost::promise<void> p;
+//    //BOOST_TEST(test_alloc_base::count == 2);
+//    p = p0;
+//    //BOOST_TEST(test_alloc_base::count == 1);
+//    boost::future<void> f = p.get_future();
+//    //BOOST_TEST(test_alloc_base::count == 1);
+//    BOOST_TEST(f.valid());
+//    try
+//    {
+//      f = p0.get_future();
+//      BOOST_TEST(false);
+//    }
+//    catch (const boost::future_error& e)
+//    {
+//      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+//    }
+//    //BOOST_TEST(test_alloc_base::count == 1);
+//  }
+  //BOOST_TEST(test_alloc_base::count == 0);
+
+
+  return boost::report_errors();
+}
+
--- a/test/sync/futures/promise/default_pass.cpp
+++ b/test/sync/futures/promise/default_pass.cpp
@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <boost/thread/future.hpp>
+
+// class promise<R>
+
+// promise();
+
+#define BOOST_THREAD_VERSION 2
+
+#include <boost/thread/future.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+  std::cout << __LINE__ << std::endl;
+
+  {
+      boost::promise<int> p;
+      boost::future<int> f = p.get_future();
+      BOOST_TEST(f.valid());
+  }
+  std::cout << __LINE__ << std::endl;
+  {
+      boost::promise<int&> p;
+      boost::future<int&> f = p.get_future();
+      BOOST_TEST(f.valid());
+  }
+  std::cout << __LINE__ << std::endl;
+  {
+      boost::promise<void> p;
+      std::cout << __LINE__ << std::endl;
+      boost::future<void> f = p.get_future();
+      std::cout << __LINE__ << std::endl;
+      BOOST_TEST(f.valid());
+  }
+
+  return boost::report_errors();
+}
+
--- a/test/sync/futures/promise/dtor_pass.cpp
+++ b/test/sync/futures/promise/dtor_pass.cpp
@@ -0,0 +1,122 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <boost/thread/future.hpp>
+
+// class promise<R>
+
+// ~promise();
+
+#define BOOST_THREAD_VERSION 2
+
+#include <boost/thread/future.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+  std::cout << __LINE__ << std::endl;
+  {
+      typedef int T;
+      boost::future<T> f;
+      {
+          boost::promise<T> p;
+          f = p.get_future();
+          p.set_value(3);
+      }
+      BOOST_TEST(f.get() == 3);
+  }
+  std::cout << __LINE__ << std::endl;
+  {
+      typedef int T;
+      boost::future<T> f;
+      {
+          boost::promise<T> p;
+          f = p.get_future();
+      }
+      try
+      {
+          T i = f.get();
+          BOOST_TEST(false);
+      }
+      catch (const boost::future_error& e)
+      {
+          BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::broken_promise));
+      }
+  }
+
+  std::cout << __LINE__ << std::endl;
+  {
+      typedef int& T;
+      int i = 4;
+      boost::future<T> f;
+      {
+          boost::promise<T> p;
+          f = p.get_future();
+          p.set_value(i);
+      }
+      BOOST_TEST(&f.get() == &i);
+  }
+  std::cout << __LINE__ << std::endl;
+  {
+      typedef int& T;
+      boost::future<T> f;
+      {
+          boost::promise<T> p;
+          f = p.get_future();
+      }
+      try
+      {
+          T i = f.get();
+          BOOST_TEST(false);
+      }
+      catch (const boost::future_error& e)
+      {
+          BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::broken_promise));
+      }
+  }
+
+  std::cout << __LINE__ << std::endl;
+  {
+      typedef void T;
+      boost::future<T> f;
+      {
+          boost::promise<T> p;
+          f = p.get_future();
+          p.set_value();
+      }
+      f.get();
+      BOOST_TEST(true);
+  }
+  std::cout << __LINE__ << std::endl;
+  {
+      typedef void T;
+      boost::future<T> f;
+      {
+          boost::promise<T> p;
+          f = p.get_future();
+      }
+      try
+      {
+          f.get();
+          BOOST_TEST(false);
+      }
+      catch (const boost::future_error& e)
+      {
+          BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::broken_promise));
+      }
+  }
+
+  return boost::report_errors();
+}
+
--- a/test/sync/futures/promise/get_future_pass.cpp
+++ b/test/sync/futures/promise/get_future_pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <boost/thread/future.hpp>
+
+// class promise<R>
+
+// future<R> get_future();
+
+#define BOOST_THREAD_VERSION 2
+
+#include <boost/thread/future.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main()
+{
+//  {
+//      boost::promise<double> p;
+//      boost::future<double> f = p.get_future();
+//      p.set_value(105.5);
+//      BOOST_TEST(f.get() == 105.5);
+//  }
+//  {
+//      boost::promise<double> p;
+//      boost::future<double> f = p.get_future();
+//      try
+//      {
+//          f = p.get_future();
+//          BOOST_TEST(false);
+//      }
+//      catch (const boost::future_error& e)
+//      {
+//          BOOST_TEST(e.code() ==  boost::system::make_error_code(boost::future_errc::future_already_retrieved));
+//      }
+//  }
+  {
+      boost::promise<double> p;
+      boost::promise<double> p0 = boost::move(p);
+      try
+      {
+          boost::future<double> f = p.get_future();
+          BOOST_TEST(false);
+      }
+      catch (const boost::future_error& e)
+      {
+          BOOST_TEST(e.code() ==  boost::system::make_error_code(boost::future_errc::no_state));
+      }
+  }
+
+
+  return boost::report_errors();
+}
+
--- a/test/sync/futures/promise/move_assign_pass.cpp
+++ b/test/sync/futures/promise/move_assign_pass.cpp
@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <future>
+
+// class promise<R>
+
+// promise& operator=(promise&& rhs);
+
+#define BOOST_THREAD_VERSION 2
+
+#include <boost/thread/future.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m0;
+boost::mutex m1;
+
+int main()
+{
+  //BOOST_TEST(test_alloc_base::count == 0);
+  {
+    //boost::promise<int> p0(boost::allocator_arg, test_allocator<int>());
+    //boost::promise<int> p(boost::allocator_arg, test_allocator<int>());
+    boost::promise<int> p0;
+    boost::promise<int> p;
+    //BOOST_TEST(test_alloc_base::count == 2);
+    p = boost::move(p0);
+    //BOOST_TEST(test_alloc_base::count == 1);
+    boost::future<int> f = p.get_future();
+    //BOOST_TEST(test_alloc_base::count == 1);
+    BOOST_TEST(f.valid());
+    try
+    {
+      f = p0.get_future();
+      BOOST_TEST(false);
+    }
+    catch (const boost::future_error& e)
+    {
+      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+    }
+    //BOOST_TEST(test_alloc_base::count == 1);
+  }
+  //BOOST_TEST(test_alloc_base::count == 0);
+  {
+    //boost::promise<int&> p0(boost::allocator_arg, test_allocator<int>());
+    //boost::promise<int&> p(boost::allocator_arg, test_allocator<int>());
+    boost::promise<int&> p0;
+    boost::promise<int&> p;
+    //BOOST_TEST(test_alloc_base::count == 2);
+    p = boost::move(p0);
+    //BOOST_TEST(test_alloc_base::count == 1);
+    boost::future<int&> f = p.get_future();
+    //BOOST_TEST(test_alloc_base::count == 1);
+    BOOST_TEST(f.valid());
+    try
+    {
+      f = p0.get_future();
+      BOOST_TEST(false);
+    }
+    catch (const boost::future_error& e)
+    {
+      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+    }
+    //BOOST_TEST(test_alloc_base::count == 1);
+  }
+  //BOOST_TEST(test_alloc_base::count == 0);
+  {
+    //boost::promise<void> p0(boost::allocator_arg, test_allocator<void>());
+    //boost::promise<void> p(boost::allocator_arg, test_allocator<void>());
+    boost::promise<void> p0;
+    boost::promise<void> p;
+    //BOOST_TEST(test_alloc_base::count == 2);
+    p = boost::move(p0);
+    //BOOST_TEST(test_alloc_base::count == 1);
+    boost::future<void> f = p.get_future();
+    //BOOST_TEST(test_alloc_base::count == 1);
+    BOOST_TEST(f.valid());
+    try
+    {
+      f = p0.get_future();
+      BOOST_TEST(false);
+    }
+    catch (const boost::future_error& e)
+    {
+      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+    }
+    //BOOST_TEST(test_alloc_base::count == 1);
+  }
+  //BOOST_TEST(test_alloc_base::count == 0);
+
+  return boost::report_errors();
+
+}
+
--- a/test/sync/futures/promise/move_ctor_pass.cpp
+++ b/test/sync/futures/promise/move_ctor_pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <future>
+
+// class promise<R>
+
+// promise(promise&& rhs);
+
+#define BOOST_THREAD_VERSION 2
+
+#include <boost/thread/future.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+int main()
+{
+  std::cout << __LINE__ << std::endl;
+  //BOOST_TEST(test_alloc_base::count == 0);
+  {
+    //boost::promise<int> p0(boost::allocator_arg, test_allocator<int>());
+    //boost::promise<int> p(boost::move(p0));
+    boost::promise<int> p0;
+    boost::promise<int> p(boost::move(p0));
+    //BOOST_TEST(test_alloc_base::count == 1);
+    std::cout << __LINE__ << std::endl;
+    boost::future<int> f = p.get_future();
+    std::cout << __LINE__ << std::endl;
+    //BOOST_TEST(test_alloc_base::count == 1);
+    BOOST_TEST(f.valid());
+    std::cout << __LINE__ << std::endl;
+    try
+    {
+      f = p0.get_future();
+      BOOST_TEST(false);
+    }
+    catch (const boost::future_error& e)
+    {
+      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+    }
+    std::cout << __LINE__ << std::endl;
+    //BOOST_TEST(test_alloc_base::count == 1);
+  }
+  std::cout << __LINE__ << std::endl;
+  //BOOST_TEST(test_alloc_base::count == 0);
+  {
+    //boost::promise<int&> p0(boost::allocator_arg, test_allocator<int>());
+    //boost::promise<int&> p(boost::move(p0));
+    boost::promise<int&> p0;
+    boost::promise<int&> p(boost::move(p0));
+    //BOOST_TEST(test_alloc_base::count == 1);
+    boost::future<int&> f = p.get_future();
+    //BOOST_TEST(test_alloc_base::count == 1);
+    BOOST_TEST(f.valid());
+    try
+    {
+      f = p0.get_future();
+      BOOST_TEST(false);
+    }
+    catch (const boost::future_error& e)
+    {
+      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+    }
+    //BOOST_TEST(test_alloc_base::count == 1);
+  }
+  //BOOST_TEST(test_alloc_base::count == 0);
+  {
+    //boost::promise<void> p0(boost::allocator_arg, test_allocator<void>());
+    //boost::promise<void> p(boost::move(p0));
+    boost::promise<void> p0;
+    boost::promise<void> p(boost::move(p0));
+    //BOOST_TEST(test_alloc_base::count == 1);
+    boost::future<void> f = p.get_future();
+    //BOOST_TEST(test_alloc_base::count == 1);
+    BOOST_TEST(f.valid());
+    try
+    {
+      f = p0.get_future();
+      BOOST_TEST(false);
+    }
+    catch (const boost::future_error& e)
+    {
+      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
+    }
+    //BOOST_TEST(test_alloc_base::count == 1);
+  }
+  //BOOST_TEST(test_alloc_base::count == 0);
+
+
+  return boost::report_errors();
+}
+
--- a/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2012 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)
+
+// <boost/thread/locks.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(mutex_type& m, adopt_lock_t);
+
+#include <boost/thread/locks.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+typedef boost::chrono::high_resolution_clock Clock;
+typedef Clock::time_point time_point;
+typedef Clock::duration duration;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
+
+boost::mutex m;
+
+void f()
+{
+  time_point t0 = Clock::now();
+  time_point t1;
+  {
+    m.lock();
+    boost::lock_guard<boost::mutex> lg(m, boost::adopt_lock);
+    t1 = Clock::now();
+  }
+  ns d = t1 - t0 - ms(250);
+  BOOST_TEST(d < ns(2500000)+ms(1000)); // within 2.5ms
+}
+
+int main()
+{
+  m.lock();
+  boost::thread t(f);
+  boost::this_thread::sleep_for(ms(250));
+  m.unlock();
+  t.join();
+
+  return boost::report_errors();
+}
+
--- a/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp
+++ b/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <boost/thread/locks.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard& operator=(lock_guard const&) = delete;
+
+#include <boost/thread/locks.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m0;
+boost::mutex m1;
+
+int main()
+{
+  boost::lock_guard<boost::mutex> lk0(m0);
+  boost::lock_guard<boost::mutex> lk1(m1);
+  lk1 = lk0;
+
+}
+
--- a/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp
+++ b/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (C) 2011 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)
+
+// <boost/thread/locks.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(lock_guard const&) = delete;
+
+
+#include <boost/thread/locks.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m0;
+boost::mutex m1;
+
+int main()
+{
+  boost::lock_guard<boost::mutex> lk0(m0);
+  boost::lock_guard<boost::mutex> lk1 = lk0;
+}
+
--- a/Show More
+++ b/Show More