Release 1.49.0 beta 1

[SVN r76721]
Thread: merge from trunk to fix #6141 , #5594 , #5040 and #5502 .
2026-02-03 09:42:16 +00:00 · 2012-01-27 18:03:17 +00:00 · 2012-01-07 20:52:57 +00:00 · 2012-01-07 20:15:14 +00:00 · 2012-01-03 17:31:50 +00:00 · 2011-06-06 08:28:31 +00:00
179 changed files with 923 additions and 12242 deletions
--- a/build/Jamfile.v2
+++ b/build/Jamfile.v2
@@ -44,15 +44,7 @@ project boost/thread
      -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
      <tag>@$(__name__).tag
      <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
+    : default-build <threading>multi
    ;

 local rule default_threadapi ( )
@@ -160,16 +152,6 @@ 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) ;
 }

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

@@ -225,7 +198,7 @@ alias thread_sources
 explicit thread_sources ;

 lib boost_thread
-    : thread_sources future.cpp
+    : thread_sources
    : <conditional>@requirements
    :
    : <link>shared:<define>BOOST_THREAD_USE_DLL=1
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -1,5 +1,4 @@
-# (C) Copyright 2008-11 Anthony Williams
-# (C) Copyright 2011-12 Vicente J. Botet Escriba
+# (C) Copyright 2008 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)
@@ -16,13 +15,13 @@ 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=2
+        <xsl:param>chunk.section.depth=3
        # 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=4
+        <xsl:param>toc.section.depth=10
        # Max depth in each TOC:
-        <xsl:param>toc.max.depth=2
+        <xsl:param>toc.max.depth=3
        # How far down we go with TOC's
        <xsl:param>generate.section.toc.level=10
        # Path for links to Boost:
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -1,54 +1,13 @@
 [/
-  (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-12 Vicente J. Botet Escriba.
+  (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:changes History]
+[section:changes Changes since]

-[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]
+[heading Changes since boost 1.41]

 Fixed Bugs:

@@ -65,7 +24,10 @@ Fixed Bugs:
 * [@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/5040 #5040] future.hpp in boost::thread does not compile with /clr.
 * [@http://svn.boost.org/trac/boost/ticket/5423 #5423] thread issues with C++0x.
+* [@http://svn.boost.org/trac/boost/ticket/5502 #5502] race condition between shared_mutex timed_lock and lock_shared.
+* [@http://svn.boost.org/trac/boost/ticket/5594 #5594] boost::shared_mutex not fully compatible with Windows CE.
 * [@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.
@@ -73,12 +35,14 @@ Fixed Bugs:
 * [@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/6141 #6141] Compilation error when boost.thread and boost.move are used together.
 * [@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.
@@ -164,13 +128,17 @@ been moved to __thread_id__.

 The following features will be included in next releases. By order of priority:

+* [@http://svn.boost.org/trac/boost/ticket/6194 #6194] Adapt to Boost.Move. 
 * [@http://svn.boost.org/trac/boost/ticket/4710 #4710] Missing async(). 
+* [@http://svn.boost.org/trac/boost/ticket/6195 #6195] Provide the standard time related interface using Boost.Chrono. 
+  * [@http://svn.boost.org/trac/boost/ticket/2637 #2637] shared mutex lock
 * 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()
+* [@http://svn.boost.org/trac/boost/ticket/2741 #2741] Proposal to manage portable and non portable thread attributes. 
+  * #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
@@ -1,5 +1,5 @@
 [/
-  (C) Copyright 2011-12 Vicente J. Botet Escriba.
+  (C) Copyright 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).
@@ -16,77 +16,76 @@
    [[30.1]        [General]  [-] [-] [-]]
    [[30.2]        [Requirements]  [-] [-] [-]]
    [[30.2.1]        [Template parameter names]  [-] [-] [-]]
-    [[30.2.2]        [Exceptions]  [Yes] [-] [#6230]]
+    [[30.2.2]        [Exceptions]  [No] [-] [#12]]
    [[30.2.3]        [Native handles]  [Yes] [-] [-]]
-    [[30.2.4]        [Timing specifications]  [Yes] [-] [#6195]]
+    [[30.2.4]        [Timing specifications]  [No] [-] [#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.2]        [BasicLockable requirements]  [No] [-] [#13]]
    [[30.2.5.3]        [Lockable requirements]  [yes] [-] [-]]
-    [[30.2.5.4]        [TimedLockable requirements]  [Yes] [-] [#6195]]
+    [[30.2.5.4]        [TimedLockable requirements]  [Partial] [chrono] [#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]        [Class thread]  [Partial] [-] [-]]
+    [[30.3.1.1]        [Class thread::id]  [Partial] [Missing noexcept, template <> struct hash<thread::id>] [#3,#4]]
+    [[30.3.1.2]        [thread constructors]  [Partial] [Missing noexcept and move semantics] [#3,#6194]]
+    [[30.3.1.3]        [thread destructor]  [Yes] [-] [-]]
+    [[30.3.1.4]        [thread assignment]  [Partial] [move semantics] [-]]
+    [[30.3.1.5]        [thread members]  [Partial] [Missing noexcept, chrono] [#3,#6195]]
+    [[30.3.1.6]        [thread static members]  [Partial] [Missing noexcept] [#3,#6195]]
    [[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.3.2]        [Namespace this_thread]  [Partial] [chrono] [#6195]]
+    [[30.4]        [Mutual exclusion]  [Partial] [-] [-]]
+    [[30.4.1]        [Mutex requirements]  [Partial] [-] [-]]
+    [[30.4.1.1]        [In general]  [Partial] [-] [-]]
+    [[30.4.1.2]        [Mutex types]  [Partial] [noexcept,delete] [#3,#5]]
+    [[30.4.1.2.1]        [Class mutex]  [Partial] [noexcept,delete] [#3,#5]]
+    [[30.4.1.2.2]        [Class recursive_mutex]  [Partial] [noexcept,delete] [#3,#5]]
+    [[30.4.1.3]        [Timed mutex types]  [Partial] [noexcept,chrono,delete] [#3,#6195,#5]]
+    [[30.4.1.3.1]        [Class timed_mutex]  [Partial] [noexcept,chrono,delete] [#3,#6195,#5]]
+    [[30.4.1.3.1]        [Class recursive_timed_mutex]  [Partial] [noexcept,chrono,delete] [#3,#6195,#5]]
+    [[30.4.2]        [Locks]  [Partial] [noexcept,chrono,move,delete,bool] [#3,#6195,#5,#6]]
+    [[30.4.2.1]        [Class template lock_guard]  [Partial] [cons/dest delete] [#5]]
+    [[30.4.2.2]        [Class template unique_lock]  [Partial] [noexcept, chrono, move, delete] [#3,#6195,#5,#6]]
+    [[30.4.2.2.1]        [unique_lock constructors, destructor, and assignment] [Partial]  [noexcept, chrono, move, delete]  [#3,#6195,#5,#6]]
+    [[30.4.2.2.2]        [unique_lock locking]  [Partial] [chrono] [,#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.4.2.2.4]        [unique_lock observers]  [Partial] [explicit operator bool] [#6]]
+    [[30.4.3]        [Generic locking algorithms]  [Partial] [Variadic,] [#7]]
+    [[30.4.4]        [Call once]  [Partial] [move,variadic] [#6194,#7]]
+    [[30.4.4.1]        [Struct once_flag] [Yes] [-] [-]]
+    [[30.4.4.2]        [Function call_once] [Yes] [-] [-]]
+    [[30.5]        [Condition variables]  [Partial] [chrono,cv_status,notify_all_at_thread_exit] [#6195,#8,#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.5.1]        [Class condition_variable]  [Partial] [chrono,cv_status] [#6195,#8]]
+    [[30.5.2]        [Class condition_variable_any]  [Partial] [chrono,cv_status] [#6195,#8]]
    [[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.5]        [Class template promise]  [Partial] [allocator,move,delete] [#10,#6194,#5]]
+    [[30.6.6]        [Class template future]  [No] [unique_future is the closest to future] [#11]]
+    [[30.6.7]        [Class template shared_future]  [Partial] [allocator,move,delete] [#10,#6194,#5]]
    [[30.6.8]        [Function template async]  [No] [async] [#4710]]
-    [[30.6.8]        [Class template packaged_task]  [Partial] [move] [#6194]]
+    [[30.6.8]        [Class template packaged_task]  [Partial] [-] [-]]
 ]

-[/
+
 [table Extension
    [[Section]     [Description]   [Comments]]
    [[30.3.1.5.x]        [interrupt]   [-]]
-    [[30.3.2.x]        [Interruption]  [-]]
+    [[30.3.1.5.y]        [operator==,operator!=]   [-]]
+    [[30.3.2.x]        [Interruprion]  [-]]
    [[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
@@ -96,6 +95,6 @@
 ]

 [endsect]
-]
+

 [endsect]
--- a/doc/condition_variables.qbk
+++ b/doc/condition_variables.qbk
@@ -1,6 +1,5 @@
 [/
-  (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-12 Vicente J. Botet Escriba.
+  (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).
@@ -10,17 +9,6 @@

 [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
@@ -96,57 +84,31 @@ 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 notify_one();
+            void notify_all();

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

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

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

            template<typename duration_type,typename predicate_type>
-            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);
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time,predicate_type predicate);

        // backwards compatibility

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

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

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

 [endsect]

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

 [variablelist

@@ -277,7 +239,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)` DEPRECATED V2]
+[section:timed_wait_rel `template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time)`]

 [variablelist

@@ -310,7 +272,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)` DEPRECATED V2]
+[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)`]

 [variablelist

@@ -330,114 +292,6 @@ 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`]
@@ -462,47 +316,24 @@ 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) // DEPRECATED V2;
+            bool timed_wait(lock_type& lock,boost::system_time const& abs_time);

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

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

            template<typename lock_type,typename duration_type,typename predicate_type>
-            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);
+            bool timed_wait(lock_type& lock,duration_type const& rel_time,predicate_type predicate);

        // backwards compatibility

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

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

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

 [endsect]

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

 [variablelist

@@ -621,7 +452,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)` DEPRECATED V2]
+[section:timed_wait_rel `template<typename lock_type,typename duration_type> bool timed_wait(lock_type& lock,duration_type const& rel_time)`]

 [variablelist

@@ -648,7 +479,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)` DEPRECATED V2]
+[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)`]

 [variablelist

@@ -667,96 +498,6 @@ 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`]
--- a/doc/future_ref.qbk
+++ b/doc/future_ref.qbk
@@ -1,5 +1,5 @@
 [/
-  (C) Copyright 2008-11 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).
--- a/doc/futures.qbk
+++ b/doc/futures.qbk
@@ -1,5 +1,5 @@
 [/
-  (C) Copyright 2008-11 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).
--- a/doc/mutex_concepts.qbk
+++ b/doc/mutex_concepts.qbk
@@ -1,6 +1,5 @@
 [/
  (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).
@@ -39,16 +38,6 @@ 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]

@@ -62,7 +51,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:] [Nothing.]]
+[[Throws:] [__thread_resource_error__ if an error occurs.]]

 ]
 [endsect]
@@ -77,7 +66,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]
@@ -91,17 +80,12 @@ 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);` DEPRECATED V2]
-* [timed_lock_duration_ref_link `template<typename DurationType> bool timed_lock(DurationType const& rel_time);` DEPRECATED V2]
+* [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);`]

-        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);
+Lock ownership acquired through a call to __timed_lock_ref__ must be released through a call to __unlock_ref__.

-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]
+[section:timed_lock `bool timed_lock(boost::system_time const& abs_time)`]

 [variablelist

@@ -117,7 +101,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)` DEPRECATED V2]
+timed_lock(DurationType const& rel_time)`]

 [variablelist

@@ -127,32 +111,6 @@ timed_lock(DurationType const& rel_time)` DEPRECATED V2]
 ]
 [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]
@@ -445,54 +403,41 @@ object passed to the constructor.]]
    class unique_lock
    {
    public:
-        unique_lock() noexcept;
+        unique_lock();
        explicit unique_lock(Lockable& m_);
        unique_lock(Lockable& m_,adopt_lock_t);
-        unique_lock(Lockable& m_,defer_lock_t) noexcept;
+        unique_lock(Lockable& m_,defer_lock_t);
        unique_lock(Lockable& m_,try_to_lock_t);
-        unique_lock(Lockable& m_,system_time const& target_time); // DEPRECATED V2
+        unique_lock(Lockable& m_,system_time const& target_time);

-        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(unique_lock<Lockable>&& other) noexcept;
-        unique_lock(detail::thread_move_t<unique_lock<Lockable> > other) noexcept;
-        unique_lock(upgrade_lock<Lockable>&& other) noexcept;
-        unique_lock(detail::thread_move_t<upgrade_lock<Lockable> > other) noexcept;
+        unique_lock(detail::thread_move_t<unique_lock<Lockable> > other);
+        unique_lock(detail::thread_move_t<upgrade_lock<Lockable> > other);

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

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

        void lock();
        bool try_lock();

        template<typename TimeDuration>
-        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);
+        bool timed_lock(TimeDuration const& relative_time);
+        bool timed_lock(::boost::system_time const& absolute_time);

        void unlock();

-        bool owns_lock() const noexcept;
-        explicit operator bool() const noexcept;
-        operator ``['unspecified-bool-type]``() const noexcept;
-        bool operator!() const noexcept;
+        bool owns_lock() const;
+        operator ``['unspecified-bool-type]``() const;
+        bool operator!() const;

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

 __unique_lock__ is more complex than __lock_guard__: not only does it provide for RAII-style locking, it also allows for deferring
@@ -588,7 +533,7 @@ returns `false`.]]

 [endsect]

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

 [variablelist

@@ -606,47 +551,6 @@ 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
@@ -700,18 +604,6 @@ boolean contexts.]]

 [endsect]

-[section:explicit_bool_conversion `explicit operator bool() const`]
-
-[variablelist
-
-[[Returns:] [`__owns_lock_ref__()`.]]
-
-[[Throws:] [Nothing.]]
-
-]
-
-[endsect]
-
 [section:operator_not `bool operator!() const`]

 [variablelist
--- a/doc/mutexes.qbk
+++ b/doc/mutexes.qbk
@@ -1,6 +1,5 @@
 [/
-  (C) Copyright 2007-11 Anthony Williams
-  (C) Copyright 2011-12 Vicente J. Botet Escriba
+  (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).
@@ -76,14 +75,10 @@ __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); // DEPRECATED V2
-        template<typename TimeDuration>
-        bool timed_lock(TimeDuration const & relative_time); // DEPRECATED V2
+        bool timed_lock(system_time const & abs_time);

-        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);
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time);

        typedef platform-specific-type native_handle_type;
        native_handle_type native_handle();
@@ -186,14 +181,10 @@ __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); // DEPRECATED V2 
-        template<typename TimeDuration>
-        bool timed_lock(TimeDuration const & relative_time); // DEPRECATED V2
+        bool timed_lock(system_time const & abs_time);

-        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);
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time);

        typedef platform-specific-type native_handle_type;
        native_handle_type native_handle();
--- a/doc/overview.qbk
+++ b/doc/overview.qbk
@@ -1,6 +1,5 @@
 [/
-  (C) Copyright 2007-12 Anthony Williams.
-  (C) Copyright 20012 Vicente J. Botet Escriba.
+  (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).
@@ -12,14 +11,13 @@ __boost_thread__ enables the use of multiple threads of execution with shared da
 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 (version 0). Anthony Williams version (version 1) was a major rewrite designed to
+The __boost_thread__ library was originally written and designed by William E. Kempf. This version is 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
@@ -30,15 +28,3 @@ each class or function, or include the master thread library header:
 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/thread.qbk
+++ b/doc/thread.qbk
@@ -1,16 +1,14 @@
 [/
-  (C) Copyright 2008-11 Anthony Williams
-  (C) Copyright 2011-12 Vicente J. Botet Escriba
+  (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).
 ]

 [article Thread
-    [quickbook 1.5]
-    [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
-    [copyright 2007-11 Anthony Williams]
-    [copyright 2011-12 Vicente J. Botet Escriba]
+    [quickbook 1.4]
+    [authors [Williams, Anthony]]
+    [copyright 2007-8 Anthony Williams]
    [purpose C++ Library for launching threads and synchronizing data between them]
    [category text]
    [license
@@ -55,9 +53,6 @@
 [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()`]]

@@ -122,22 +117,14 @@


 [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()`]]
@@ -153,21 +140,11 @@
 [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]
--- a/doc/thread_ref.qbk
+++ b/doc/thread_ref.qbk
@@ -1,6 +1,5 @@
 [/
  (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).
@@ -8,35 +7,7 @@

 [section:thread_management Thread Management]

-[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]
+[heading Synopsis]

 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
@@ -53,14 +24,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.]

-[section:launching Launching threads]
+[heading 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
@@ -97,99 +68,12 @@ to callable functions.

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

-[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]
+[heading 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. 

-[endsect]
-
-[section:join Joining and detaching]
+[heading 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,
@@ -202,9 +86,7 @@ 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.

-[endsect]
-
-[section:interruption Interruption]
+[heading 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)
@@ -260,25 +142,16 @@ 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()` DEPRECATED V2]
-* `boost::__thread::__try_join_for()`,
-* `boost::__thread::__try_join_until()`,
+* [timed_join_link `boost::thread::timed_join()`]
 * [cond_wait_link `boost::condition_variable::wait()`]
-* [cond_timed_wait_link `boost::condition_variable::timed_wait()` DEPRECATED V2]
-* `boost::__condition_variable::__wait_for()`
-* `boost::__condition_variable::__wait_until()`
+* [cond_timed_wait_link `boost::condition_variable::timed_wait()`]
 * [cond_any_wait_link `boost::condition_variable_any::wait()`]
-* [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()`
+* [cond_any_timed_wait_link `boost::condition_variable_any::timed_wait()`]
+* [link thread.thread_management.thread.sleep `boost::thread::sleep()`]
+* __sleep__
 * __interruption_point__

-[endsect]
-
-[section:id Thread IDs]
+[heading 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
@@ -290,15 +163,14 @@ 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] 
+[heading 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); 
@@ -306,21 +178,19 @@ In general, it is not safe to use this handle with operations that can conflict
  pthread_detach(hnd); 
  assert(t.joinable()); 

-[endsect]
-
-[section:native_from Using Boost.Thread interfaces in a native thread] 
+[heading 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. 
+The user can access to some synchronization functions related to the native current thread using the `boost::this_thread` `yield`, `sleep`, functions. 


  int main() { 
    // ... 
-    boost::this_thread::sleep_for(boost::chrono::milliseconds(10)); 
+    boost::this_thread::sleep(); 
    // ... 
  } 

@@ -331,16 +201,6 @@ The `boost::this_thread` interrupt related functions behave in a degraded mode w

 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>
@@ -348,12 +208,7 @@ This behavior is incompatible with the current Boost.Thread design, so the use o
    class thread
    {
    public:
-        thread() noexcept;
-        thread(const thread&) = delete;
-        thread& operator=(const thread&) = delete;
-
-        thread(thread&&) noexcept;
-        thread& operator=(thread&&) noexcept;
+        thread();
        ~thread();

        template <class F>
@@ -365,32 +220,27 @@ This behavior is incompatible with the current Boost.Thread design, so the use o
        template <class F>
        thread(detail::thread_move_t<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();

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

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

-        bool joinable() const noexcept;
+        bool joinable() const;
        void join();
-        bool timed_join(const system_time& wait_until); // DEPRECATED V2
+        bool timed_join(const system_time& wait_until);
+
        template<typename TimeDuration>
-        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);
+        bool timed_join(TimeDuration const& rel_time);

        void detach();

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

        typedef platform-specific-type native_handle_type;
        native_handle_type native_handle();
@@ -399,20 +249,19 @@ This behavior is incompatible with the current Boost.Thread design, so the use o
        bool interruption_requested() const;

        // backwards compatibility
-        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
+        bool operator==(const thread& other) const;
+        bool operator!=(const thread& other) const;

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

-    void swap(thread& lhs,thread& rhs) noexcep;
+    void swap(thread& lhs,thread& rhs);
    detail::thread_move_t<thread> move(detail::thread_move_t<thread> t);

 [section:default_constructor Default Constructor]

-    thread() noexcep;
+    thread();

 [variablelist

@@ -426,7 +275,6 @@ This behavior is incompatible with the current Boost.Thread design, so the use o

 [section:move_constructor Move Constructor]

-    thread(thread&& other) noexcept;
    thread(detail::thread_move_t<thread> other);

 [variablelist
@@ -443,7 +291,6 @@ This behavior is incompatible with the current Boost.Thread design, so the use o

 [section:move_assignment Move assignment operator]

-    thread& operator=(thread&& other) noexcept;
    thread& operator=(detail::thread_move_t<thread> other);

 [variablelist
@@ -475,13 +322,7 @@ 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. 
-
-]]
+[[Throws:] [__thread_resource_error__ if an error occurs.]]

 ]

@@ -505,12 +346,6 @@ are copied into internal storage for access by the new thread.]]]

 [[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`.]]

 ]
@@ -533,7 +368,7 @@ are copied into internal storage for access by the new thread.]]]

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

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

 [variablelist

@@ -558,19 +393,7 @@ are copied into internal storage for access by the new thread.]]]

 [[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 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.
-] 
-
-]]
+[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted.]]

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

@@ -578,7 +401,7 @@ are copied into internal storage for access by the new thread.]]]

 [endsect]

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

    bool timed_join(const system_time& wait_until);

@@ -599,19 +422,7 @@ 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 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.
-] 
-
-]]
+[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted.]]

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

@@ -619,86 +430,6 @@ 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();
@@ -718,7 +449,7 @@ unchanged.]]

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

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

 [variablelist

@@ -750,7 +481,7 @@ predefined __interruption_points__ with interruption enabled .]]

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

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

 [variablelist

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

 [endsect]

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

    void sleep(system_time const& abs_time);

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

 [endsect]

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

    void yield();

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

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

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

 [variablelist

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

    #include <boost/thread/thread.hpp>

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

 [variablelist

@@ -891,14 +622,14 @@ Enables moving thread objects. e.g.
    class thread::id
    {
    public:
-        id() noexcept;
+        id();

-        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;
+        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;

        template<class charT, class traits>
        friend std::basic_ostream<charT, traits>& 
@@ -907,7 +638,7 @@ Enables moving thread objects. e.g.

 [section:constructor Default constructor]

-    id() noexcept;
+    id();

 [variablelist

@@ -921,7 +652,7 @@ Enables moving thread objects. e.g.

 [section:is_equal `operator==`]

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

 [variablelist

@@ -936,7 +667,7 @@ otherwise.]]

 [section:not_equal `operator!=`]

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

 [variablelist

@@ -951,7 +682,7 @@ the other represent __not_a_thread__, `false` otherwise.]]

 [section:less_than `operator<`]

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

 [variablelist

@@ -970,7 +701,7 @@ execution.]]

 [section:greater_than `operator>`]

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

 [variablelist

@@ -984,7 +715,7 @@ execution.]]

 [section:less_than_or_equal `operator<=`]

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

 [variablelist

@@ -998,7 +729,7 @@ execution.]]

 [section:greater_than_or_equal `operator>=`]

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

 [variablelist

@@ -1034,34 +765,13 @@ 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() noexcept;
+        thread::id get_id();
    }

 [variablelist
@@ -1131,7 +841,7 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

 [endsect]

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

    #include <boost/thread/thread.hpp>

@@ -1156,55 +866,6 @@ specified by `rel_time` has elapsed or the time point specified by

 [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>
--- a/include/boost/thread/barrier.hpp
+++ b/include/boost/thread/barrier.hpp
@@ -2,7 +2,7 @@
 // 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
@@ -28,14 +28,14 @@ namespace boost
            : m_threshold(count), m_count(count), m_generation(0)
        {
            if (count == 0)
-                boost::throw_exception(thread_exception(system::errc::invalid_argument, "barrier constructor: count cannot be zero."));
+                boost::throw_exception(std::invalid_argument("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
@@ -1,26 +0,0 @@
-//  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
@@ -10,6 +10,7 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>

+
 #if !defined BOOST_THREAD_VERSION
 #define BOOST_THREAD_VERSION 1
 #else
@@ -18,18 +19,6 @@
 #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 ! 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
--- a/include/boost/thread/detail/scoped_enum.hpp
+++ b/include/boost/thread/detail/scoped_enum.hpp
@@ -1,113 +0,0 @@
-// 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
@@ -4,18 +4,12 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // (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>
@@ -31,13 +25,6 @@
 #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>

@@ -48,19 +35,6 @@

 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>
@@ -70,25 +44,18 @@ namespace boost
        public:
 #ifndef BOOST_NO_RVALUE_REFERENCES
            thread_data(F&& f_):
-              f(boost::forward<F>(f_))
+                f(static_cast<F&&>(f_))
+            {}
+            thread_data(F& f_):
+                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
            void run()
            {
@@ -143,39 +110,15 @@ namespace boost

    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:
-//      BOOST_MOVABLE_BUT_NOT_COPYABLE(thread)
-
-#if defined BOOST_THREAD_USES_MOVE
-    private:
-      //thread(thread const&);
-      thread(thread &);
-      //thread& operator=(thread const&);
-      thread& operator=(thread &);
-#else
-    private:
-      thread(thread&);
-      thread& operator=(thread&);
-#endif
-    public:
-#endif // BOOST_NO_DELETED_FUNCTIONS
    private:
+        thread(thread&);
+        thread& operator=(thread&);

        void release_handle();

        detail::thread_data_ptr thread_info;

        void start_thread();
-        void start_thread(const attributes& attr);

        explicit thread(detail::thread_data_ptr data);

@@ -185,13 +128,11 @@ namespace boost
        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> >(
-                boost::forward<F>(f)));
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(static_cast<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(*)()> >(
-                boost::forward<void(*)()>(f)));
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(static_cast<void(*&&)()>(f)));
        }
 #else
        template<typename F>
@@ -199,32 +140,23 @@ 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));
        }

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

 #ifndef BOOST_NO_RVALUE_REFERENCES
-#ifdef BOOST_MSVCXX
+#ifdef BOOST_MSVC
        template <class 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)))
@@ -232,46 +164,30 @@ namespace boost
            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))))
+        template <class F>
+        thread(F&& f):
+            thread_info(make_thread_info(static_cast<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) BOOST_NOEXCEPT
+        thread(thread&& other)
        {
            thread_info.swap(other.thread_info);
        }

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

-//        thread&& move()
-//        {
-//            return static_cast<thread&&>(*this);
-//        }
+        thread&& move()
+        {
+            return static_cast<thread&&>(*this);
+        }

 #else
 #ifdef BOOST_NO_SFINAE
@@ -281,26 +197,6 @@ namespace boost
        {
            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):
@@ -308,52 +204,8 @@ namespace boost
        {
            start_thread();
        }
-        template <class 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))
@@ -361,19 +213,11 @@ namespace boost
            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)
@@ -381,14 +225,6 @@ namespace boost
            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)
        {
@@ -397,18 +233,6 @@ namespace boost
            return *this;
        }
 #endif
-#endif
-
-#if defined BOOST_THREAD_USES_MOVE
-      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();
@@ -419,12 +243,11 @@ namespace boost
            detail::thread_move_t<thread> x(*this);
            return x;
        }
-#endif

 #endif

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

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

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


-        bool joinable() const BOOST_NOEXCEPT;
+        bool joinable() const;
        void join();
-#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_for(chrono::ceil<chrono::milliseconds>(rel_time));
-        }
-        template <class Clock, class Duration>
-        bool try_join_until(const chrono::time_point<Clock, Duration>& t)
-        {
-          using namespace chrono;
-          typename Clock::time_point  c_now = Clock::now();
-          return try_join_for(chrono::ceil<chrono::milliseconds>(t - c_now));
-        }
-#endif
-    private:
-#ifdef BOOST_THREAD_USES_CHRONO
-      bool do_try_join_for(chrono::milliseconds const &rel_time_in_milliseconds);
-#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
+        bool timed_join(const system_time& wait_until);

        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() BOOST_NOEXCEPT;
+        static unsigned hardware_concurrency();

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

@@ -580,7 +337,7 @@ namespace boost
        bool operator==(const thread& other) const;
        bool operator!=(const thread& other) const;

-        static inline void yield() BOOST_NOEXCEPT
+        static inline void yield()
        {
            this_thread::yield();
        }
@@ -595,7 +352,7 @@ namespace boost
        bool interruption_requested() const;
    };

-    inline void swap(thread& lhs,thread& rhs) BOOST_NOEXCEPT
+    inline void swap(thread& lhs,thread& rhs)
    {
        return lhs.swap(rhs);
    }
@@ -610,26 +367,15 @@ namespace boost
        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
    {
-        thread::id BOOST_THREAD_DECL get_id() BOOST_NOEXCEPT;
+        thread::id BOOST_THREAD_DECL get_id();

        void BOOST_THREAD_DECL interruption_point();
        bool BOOST_THREAD_DECL interruption_enabled();
@@ -644,55 +390,48 @@ namespace boost
    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 BOOST_THREAD_DECL this_thread::get_id() BOOST_NOEXCEPT;
+        friend id BOOST_THREAD_DECL this_thread::get_id();
    public:
-        id() BOOST_NOEXCEPT:
+        id():
            thread_data()
        {}

-        id(const id& other) BOOST_NOEXCEPT :
+        id(const id& other):
            thread_data(other.thread_data)
        {}

-        bool operator==(const id& y) const BOOST_NOEXCEPT
+        bool operator==(const id& y) const
        {
            return thread_data==y.thread_data;
        }

-        bool operator!=(const id& y) const BOOST_NOEXCEPT
+        bool operator!=(const id& y) const
        {
            return thread_data!=y.thread_data;
        }

-        bool operator<(const id& y) const BOOST_NOEXCEPT
+        bool operator<(const id& y) const
        {
            return thread_data<y.thread_data;
        }

-        bool operator>(const id& y) const BOOST_NOEXCEPT
+        bool operator>(const id& y) const
        {
            return y.thread_data<thread_data;
        }

-        bool operator<=(const id& y) const BOOST_NOEXCEPT
+        bool operator<=(const id& y) const
        {
            return !(y.thread_data<thread_data);
        }

-        bool operator>=(const id& y) const BOOST_NOEXCEPT
+        bool operator>=(const id& y) const
        {
            return !(thread_data<y.thread_data);
        }
@@ -701,7 +440,7 @@ namespace boost
 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
        template<class charT, class traits>
        friend BOOST_SYMBOL_VISIBLE
-  std::basic_ostream<charT, traits>&
+	std::basic_ostream<charT, traits>&
        operator<<(std::basic_ostream<charT, traits>& os, const id& x)
        {
            if(x.thread_data)
@@ -717,7 +456,7 @@ namespace boost
 #else
        template<class charT, class traits>
        BOOST_SYMBOL_VISIBLE
-  std::basic_ostream<charT, traits>&
+	std::basic_ostream<charT, traits>&
        print(std::basic_ostream<charT, traits>& os) const
        {
            if(thread_data)
@@ -782,6 +521,13 @@ namespace boost
        void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
    }

+#ifdef BOOST_NO_RVALUE_REFERENCES
+    template <>
+    struct has_move_emulation_enabled_aux<thread>
+      : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+    {};
+#endif
+
    namespace this_thread
    {
        template<typename F>
--- a/include/boost/thread/exceptions.hpp
+++ b/include/boost/thread/exceptions.hpp
@@ -2,7 +2,7 @@
 // William E. Kempf
 // 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,9 +18,6 @@

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

 #include <boost/config/abi_prefix.hpp>

@@ -31,188 +28,151 @@ namespace boost
    {};

    class BOOST_SYMBOL_VISIBLE thread_exception:
-        public system::system_error
-        //public std::exception
+        public std::exception
    {
-          typedef system::system_error base_type;
+    protected:
+        thread_exception():
+            m_sys_err(0)
+        {}
+    
+        thread_exception(int sys_err_code):
+            m_sys_err(sys_err_code)
+        {}
+    
+
    public:
-        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)
-        {
-        }
-        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();
+            return m_sys_err;
        }
+    

+    private:
+        int m_sys_err;
    };

    class BOOST_SYMBOL_VISIBLE condition_error:
-        public system::system_error
-        //public std::exception
+        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)
-          {
-          }
+        const char* what() const throw()
+        {
+            return "Condition error";
+        }
    };
-
+    

    class BOOST_SYMBOL_VISIBLE lock_error:
        public thread_exception
    {
-          typedef thread_exception base_type;
    public:
        lock_error()
-        : base_type(0, "boost::lock_error")
        {}
-
-        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)
-        {
-        }
-
+    
+        lock_error(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
        ~lock_error() throw()
        {}
+    

+        virtual const char* what() const throw()
+        {
+            return "boost::lock_error";
+        }
    };

    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")
-          {}
-
-          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)
-          {
-          }
-
-
+        thread_resource_error()
+        {}
+    
+        thread_resource_error(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
        ~thread_resource_error() throw()
        {}
+    

+        virtual const char* what() const throw()
+        {
+            return "boost::thread_resource_error";
+        }
+    
    };

    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)
-          {
-          }
+        unsupported_thread_option()
+        {}
+    
+        unsupported_thread_option(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
+        ~unsupported_thread_option() throw()
+        {}
+    

+        virtual const char* what() const throw()
+        {
+            return "boost::unsupported_thread_option";
+        }
+    
    };

    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 sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
+        ~invalid_thread_argument() throw()
+        {}
+    

-        invalid_thread_argument( int ev )
-        : base_type(ev, "boost::invalid_thread_argument")
+        virtual const char* what() const throw()
        {
+            return "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)
-          {
-          }
+        thread_permission_error()
+        {}
+    
+        thread_permission_error(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
+        ~thread_permission_error() throw()
+        {}
+    

+        virtual const char* what() const throw()
+        {
+            return "boost::thread_permission_error";
+        }
+    
    };

 } // namespace boost
--- 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,7 +22,6 @@

 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
@@ -4,16 +4,11 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // (C) Copyright 2007-10 Anthony Williams
-// (C) Copyright 2011 Vicente J. Botet Escriba

 #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>

@@ -64,22 +59,18 @@ namespace boost
        this_thread::interruption_point();
        if(res)
        {
-            boost::throw_exception(condition_error(res, "boost:: condition_variable constructor failed in pthread_cond_wait"));
+            boost::throw_exception(condition_error());
        }
    }

-    inline bool condition_variable::do_timed_wait(
-                unique_lock<mutex>& m,
-                struct timespec const &timeout)
+    inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
    {
-        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);
+            struct timespec const timeout=detail::get_timespec(wait_until);
            cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
        }
        this_thread::interruption_point();
@@ -89,18 +80,18 @@ namespace boost
        }
        if(cond_res)
        {
-            boost::throw_exception(condition_error(cond_res, "condition_variable failed in pthread_cond_timedwait"));
+            boost::throw_exception(condition_error());
        }
        return true;
    }

-    inline void condition_variable::notify_one() BOOST_NOEXCEPT
+    inline void condition_variable::notify_one()
    {
        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
        BOOST_VERIFY(!pthread_cond_signal(&cond));
    }

-    inline void condition_variable::notify_all() BOOST_NOEXCEPT
+    inline void condition_variable::notify_all()
    {
        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
        BOOST_VERIFY(!pthread_cond_broadcast(&cond));
@@ -111,15 +102,8 @@ namespace boost
        pthread_mutex_t internal_mutex;
        pthread_cond_t cond;

-#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()
@@ -127,13 +111,13 @@ namespace boost
            int const res=pthread_mutex_init(&internal_mutex,NULL);
            if(res)
            {
-                boost::throw_exception(thread_resource_error(res, "condition_variable_any failed in pthread_mutex_init"));
+                boost::throw_exception(thread_resource_error());
            }
            int const res2=pthread_cond_init(&cond,NULL);
            if(res2)
            {
                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-                boost::throw_exception(thread_resource_error(res, "condition_variable_any failed in pthread_cond_init"));
+                boost::throw_exception(thread_resource_error());
            }
        }
        ~condition_variable_any()
@@ -155,7 +139,7 @@ namespace boost
            this_thread::interruption_point();
            if(res)
            {
-                boost::throw_exception(condition_error(res, "condition_variable_any failed in pthread_cond_wait"));
+                boost::throw_exception(condition_error());
            }
        }

@@ -169,7 +153,23 @@ namespace boost
        bool timed_wait(lock_type& m,boost::system_time const& wait_until)
        {
            struct timespec const timeout=detail::get_timespec(wait_until);
-            return do_timed_wait(m, 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());
+            }
+            return true;
        }
        template<typename lock_type>
        bool timed_wait(lock_type& m,xtime const& wait_until)
@@ -206,134 +206,17 @@ namespace boost
            return timed_wait(m,get_system_time()+wait_duration,pred);
        }

-#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
+        void notify_one()
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
            BOOST_VERIFY(!pthread_cond_signal(&cond));
        }

-        void notify_all() BOOST_NOEXCEPT
+        void notify_all()
        {
            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,41 +4,27 @@
 // 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;

-#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
+        condition_variable(condition_variable&);
+        condition_variable& operator=(condition_variable&);

    public:
        condition_variable()
@@ -46,13 +32,13 @@ namespace boost
            int const res=pthread_mutex_init(&internal_mutex,NULL);
            if(res)
            {
-                boost::throw_exception(thread_resource_error(res, "boost:: condition_variable constructor failed in pthread_mutex_init"));
+                boost::throw_exception(thread_resource_error());
            }
            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"));
+                boost::throw_exception(thread_resource_error());
            }
        }
        ~condition_variable()
@@ -73,32 +59,21 @@ namespace boost
            while(!pred()) wait(m);
        }

-        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)
+        inline bool timed_wait(unique_lock<mutex>& m,
+                               boost::system_time const& wait_until);
+        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)
+        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())
            {
@@ -109,127 +84,25 @@ 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() 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);
+        void notify_one();
+        void notify_all();
    };
 }

--- a/include/boost/thread/pthread/mutex.hpp
+++ b/include/boost/thread/pthread/mutex.hpp
@@ -16,10 +16,6 @@
 #include <errno.h>
 #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 && _POSIX_C_SOURCE>=200112L
@@ -33,16 +29,9 @@ namespace boost
 {
    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:
+        mutex(mutex const&);
+        mutex& operator=(mutex const&);
        pthread_mutex_t m;
    public:
        mutex()
@@ -50,7 +39,7 @@ namespace boost
            int const res=pthread_mutex_init(&m,NULL);
            if(res)
            {
-                boost::throw_exception(thread_resource_error(res, "boost:: mutex constructor failed in pthread_mutex_init"));
+                boost::throw_exception(thread_resource_error());
            }
        }
        ~mutex()
@@ -69,9 +58,9 @@ namespace boost
            {
                res = pthread_mutex_lock(&m);
            } while (res == EINTR);
-            if (res)
+            if(res)
            {
-                boost::throw_exception(lock_error(res,"boost: mutex lock failed in pthread_mutex_lock"));
+                boost::throw_exception(lock_error(res));
            }
        }

@@ -94,17 +83,12 @@ namespace boost
            } 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(false && "boost: mutex try_lock failed in pthread_mutex_trylock");
-                return false;
+                boost::throw_exception(lock_error(res));
            }

            return !res;
        }

-#define BOOST_THREAD_DEFINES_MUTEX_NATIVE_HANDLE
        typedef pthread_mutex_t* native_handle_type;
        native_handle_type native_handle()
        {
@@ -119,16 +103,9 @@ namespace boost

    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
+        timed_mutex(timed_mutex const&);
+        timed_mutex& operator=(timed_mutex const&);
    private:
        pthread_mutex_t m;
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
@@ -141,14 +118,14 @@ namespace boost
            int const res=pthread_mutex_init(&m,NULL);
            if(res)
            {
-                boost::throw_exception(thread_resource_error(res, "boost:: timed_mutex constructor failed in pthread_mutex_init"));
+                boost::throw_exception(thread_resource_error());
            }
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
            int const res2=pthread_cond_init(&cond,NULL);
            if(res2)
            {
                BOOST_VERIFY(!pthread_mutex_destroy(&m));
-                boost::throw_exception(thread_resource_error(res2, "boost:: timed_mutex constructor failed in pthread_cond_init"));
+                boost::throw_exception(thread_resource_error());
            }
            is_locked=false;
 #endif
@@ -188,16 +165,19 @@ namespace boost
            BOOST_ASSERT(!res || res==EBUSY);
            return !res;
        }
-
-
-    private:
-        bool do_try_lock_until(struct timespec const &timeout)
+        bool timed_lock(system_time const & abs_time)
        {
-          int const res=pthread_mutex_timedlock(&m,&timeout);
-          BOOST_ASSERT(!res || res==ETIMEDOUT);
-          return !res;
+            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()
+        {
+            return &m;
        }
-    public:

 #else
        void lock()
@@ -228,9 +208,9 @@ namespace boost
            return true;
        }

-    private:
-        bool do_try_lock_until(struct timespec const &timeout)
+        bool timed_lock(system_time const & abs_time)
        {
+            struct timespec const timeout=detail::get_timespec(abs_time);
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            while(is_locked)
            {
@@ -244,55 +224,8 @@ 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
@@ -10,6 +10,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt)

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

 #include <pthread.h>
 #include <boost/assert.hpp>
@@ -21,39 +22,11 @@
 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();
@@ -62,6 +35,10 @@ namespace boost
        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
    template<typename Function>
--- a/include/boost/thread/pthread/recursive_mutex.hpp
+++ b/include/boost/thread/pthread/recursive_mutex.hpp
@@ -19,10 +19,6 @@
 #include <errno.h>
 #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
@@ -40,16 +36,9 @@ namespace boost
 {
    class recursive_mutex
    {
-#ifndef BOOST_NO_DELETED_FUNCTIONS
-    public:
-      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:
+        recursive_mutex(recursive_mutex const&);
+        recursive_mutex& operator=(recursive_mutex const&);
        pthread_mutex_t m;
 #ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
        pthread_cond_t cond;
@@ -66,33 +55,33 @@ namespace boost
            int const init_attr_res=pthread_mutexattr_init(&attr);
            if(init_attr_res)
            {
-                boost::throw_exception(thread_resource_error(init_attr_res, "boost:: recursive_mutex constructor failed in pthread_mutexattr_init"));
+                boost::throw_exception(thread_resource_error());
            }
            int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
            if(set_attr_res)
            {
                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
-                boost::throw_exception(thread_resource_error(set_attr_res, "boost:: recursive_mutex constructor failed in pthread_mutexattr_settype"));
+                boost::throw_exception(thread_resource_error());
            }

            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_mutex constructor failed in pthread_mutex_init"));
+                boost::throw_exception(thread_resource_error());
            }
            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_mutex constructor failed in pthread_mutex_init"));
+                boost::throw_exception(thread_resource_error());
            }
            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_mutex constructor failed in pthread_cond_init"));
+                boost::throw_exception(thread_resource_error());
            }
            is_locked=false;
            count=0;
@@ -123,7 +112,6 @@ namespace boost
            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()
        {
@@ -182,15 +170,9 @@ namespace boost

    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
+        recursive_timed_mutex(recursive_timed_mutex const&);
+        recursive_timed_mutex& operator=(recursive_timed_mutex const&);
    private:
        pthread_mutex_t m;
 #ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
@@ -208,32 +190,32 @@ namespace boost
            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"));
+                boost::throw_exception(thread_resource_error());
            }
            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"));
+                boost::throw_exception(thread_resource_error());
            }

            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::throw_exception(thread_resource_error());
            }
            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"));
+                boost::throw_exception(thread_resource_error());
            }
            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"));
+                boost::throw_exception(thread_resource_error());
            }
            is_locked=false;
            count=0;
@@ -270,15 +252,19 @@ namespace boost
            BOOST_ASSERT(!res || res==EBUSY);
            return !res;
        }
-    private:
-        bool do_try_lock_until(struct timespec const &timeout)
+        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;
        }

-    public:
+        typedef pthread_mutex_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &m;
+        }

 #else
        void lock()
@@ -322,9 +308,9 @@ namespace boost
            return true;
        }

-    private:
-        bool do_try_lock_until(struct timespec const &timeout)
+        bool timed_lock(system_time const & abs_time)
        {
+            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()))
            {
@@ -345,56 +331,8 @@ 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
@@ -12,10 +12,6 @@
 #include <boost/thread/mutex.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>

@@ -47,17 +43,7 @@ namespace boost
        }


-#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};
@@ -116,40 +102,7 @@ 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)
-        {
-          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_for(lk,rel_time))
-              {
-                  return false;
-              }
-          }
-          ++state.shared_count;
-          return true;
-        }
-        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 lk(state_change);
@@ -213,55 +166,6 @@ 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)
-        {
-          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_for(lk,rel_time))
-              {
-                  if(state.shared_count || state.exclusive)
-                  {
-                      state.exclusive_waiting_blocked=false;
-                      release_waiters();
-                      return false;
-                  }
-                  break;
-              }
-          }
-          state.exclusive=true;
-          return true;
-        }
-        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 lk(state_change);
@@ -324,48 +228,6 @@ namespace boost
            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)
-        {
-          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::no_timeout == shared_cond.wait_for(lk,rel_time))
-              {
-                  if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
-                  {
-                      return false;
-                  }
-                  break;
-              }
-          }
-          ++state.shared_count;
-          state.upgrade=true;
-          return true;
-        }
-        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::no_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 lk(state_change);
@@ -391,12 +253,9 @@ namespace boost
            {
                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;
@@ -420,19 +279,6 @@ namespace boost
            release_waiters();
        }

-#if 0 // To be added
-        bool try_unlock_upgrade_and_lock();
-        template <class Rep, class Period>
-            bool
-            try_unlock_upgrade_and_lock_for(
-                                const chrono::duration<Rep, Period>& rel_time);
-        template <class Clock, class Duration>
-            bool
-            try_unlock_upgrade_and_lock_until(
-                          const chrono::time_point<Clock, Duration>& abs_time);
-#endif
-
-        // Shared <-> Exclusive
        void unlock_and_lock_shared()
        {
            boost::mutex::scoped_lock lk(state_change);
@@ -442,19 +288,6 @@ namespace boost
            release_waiters();
        }

-#if 0 // To be added
-        bool try_unlock_shared_and_lock();
-        template <class Rep, class Period>
-            bool
-            try_unlock_shared_and_lock_for(
-                                const chrono::duration<Rep, Period>& rel_time);
-        template <class Clock, class Duration>
-            bool
-            try_unlock_shared_and_lock_until(
-                          const chrono::time_point<Clock, Duration>& abs_time);
-#endif
-
-        // Shared <-> Upgrade
        void unlock_upgrade_and_lock_shared()
        {
            boost::mutex::scoped_lock lk(state_change);
@@ -462,20 +295,7 @@ namespace boost
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }
-
-#if 0 // To be added
-        bool try_unlock_shared_and_lock_upgrade();
-        template <class Rep, class Period>
-            bool
-            try_unlock_shared_and_lock_upgrade_for(
-                                const chrono::duration<Rep, Period>& rel_time);
-        template <class Clock, class Duration>
-            bool
-            try_unlock_shared_and_lock_upgrade_until(
-                          const chrono::time_point<Clock, Duration>& abs_time);
-#endif
    };
-
 }

 #include <boost/config/abi_suffix.hpp>
--- a/include/boost/thread/pthread/thread_data.hpp
+++ b/include/boost/thread/pthread/thread_data.hpp
@@ -15,55 +15,11 @@
 #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
@@ -172,10 +128,7 @@ namespace boost

    namespace this_thread
    {
-#ifdef BOOST_THREAD_USES_CHRONO
-        void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns);
-#endif
-        void BOOST_THREAD_DECL yield() BOOST_NOEXCEPT;
+        void BOOST_THREAD_DECL yield();

 #ifdef __DECXXX
        /// Workaround of DECCXX issue of incorrect template substitution
--- 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
@@ -22,7 +22,6 @@
 #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/v2/thread.hpp
+++ b/include/boost/thread/v2/thread.hpp
@@ -1,56 +0,0 @@
-// 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
@@ -11,10 +11,6 @@

 #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>

@@ -68,20 +64,6 @@ namespace boost
                return timed_lock(get_system_time()+timeout);
            }

-#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)
@@ -123,28 +105,7 @@ 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
@@ -15,10 +15,7 @@
 #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
@@ -145,34 +142,6 @@ namespace boost
                }
                return true;
            }
-            bool try_lock_for(chrono::milliseconds const& rel_time)
-            {
-                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
-                    {
-                        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;
-            }

            template<typename Duration>
            bool timed_lock(Duration const& timeout)
@@ -185,20 +154,6 @@ namespace boost
                return timed_lock(system_time(timeout));
            }

-        template <class Rep, class Period>
-        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
-        {
-          using namespace chrono;
-          return try_lock_for(ceil<milliseconds>(rel_time));
-        }
-        template <class Clock, class Duration>
-        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
-        {
-          using namespace chrono;
-          typename Clock::time_point  c_now = Clock::now();
-          return try_lock_for(ceil<milliseconds>(t - c_now));
-        }
-
            void unlock()
            {
                long const offset=lock_flag_value;
--- a/include/boost/thread/win32/condition_variable.hpp
+++ b/include/boost/thread/win32/condition_variable.hpp
@@ -10,18 +10,12 @@
 #include <limits.h>
 #include <boost/assert.hpp>
 #include <algorithm>
-#include <boost/thread/cv_status.hpp>
-//#include <boost/thread/thread.hpp>
-#include <boost/thread/win32/thread_data.hpp>
+#include <boost/thread/thread.hpp>
 #include <boost/thread/thread_time.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>

@@ -253,7 +247,7 @@ namespace boost
            ~basic_condition_variable()
            {}

-            void notify_one() BOOST_NOEXCEPT
+            void notify_one()
            {
                if(detail::interlocked_read_acquire(&total_count))
                {
@@ -274,7 +268,7 @@ namespace boost
                }
            }

-            void notify_all() BOOST_NOEXCEPT
+            void notify_all()
            {
                if(detail::interlocked_read_acquire(&total_count))
                {
@@ -353,58 +347,6 @@ 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:
@@ -467,58 +409,6 @@ 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/shared_mutex.hpp
+++ b/include/boost/thread/win32/shared_mutex.hpp
@@ -502,8 +502,6 @@ namespace boost
                    if(last_reader)
                    {
                        release_waiters(old_state);
-                    } else {
-                        release_waiters(old_state);
                    }
                    break;
                }
--- a/include/boost/thread/win32/thread_data.hpp
+++ b/include/boost/thread/win32/thread_data.hpp
@@ -10,51 +10,11 @@
 #include <boost/thread/thread_time.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;
@@ -193,7 +153,7 @@ namespace boost

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

        bool BOOST_THREAD_DECL interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time);
        inline void interruptible_wait(uintmax_t milliseconds)
@@ -214,12 +174,6 @@ namespace boost
        {
            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
    }

 }
--- a/src/future.cpp
+++ b/src/future.cpp
@@ -1,68 +0,0 @@
-// (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;
-  }
-
-  future_error::future_error(system::error_code ec)
-      : logic_error(ec.message()),
-        ec_(ec)
-  {
-  }
-
-//  future_error::~future_error() //BOOST_NOEXCEPT
-//  {
-//  }
-
-
-
-}
--- 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,7 +8,6 @@
 #include <boost/assert.hpp>
 #include <pthread.h>
 #include <stdlib.h>
-#include <memory>

 namespace boost
 {
@@ -22,7 +21,7 @@ namespace boost
        {
            pthread_key_t epoch_tss_key;
            pthread_once_t epoch_tss_key_flag=PTHREAD_ONCE_INIT;
-
+            
            extern "C"
            {
                static void delete_epoch_tss_data(void* data)
@@ -35,26 +34,8 @@ namespace boost
                    BOOST_VERIFY(!pthread_key_create(&epoch_tss_key,delete_epoch_tss_data));
                }
            }
-
-#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
-            {
-                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));
@@ -68,5 +49,5 @@ namespace boost
            return *static_cast<boost::uintmax_t*>(data);
        }
    }
-
+    
 }
--- a/src/pthread/thread.cpp
+++ b/src/pthread/thread.cpp
@@ -1,7 +1,6 @@
 // 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
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -88,23 +87,6 @@ namespace boost
                }
            }

-#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()
            {
@@ -195,7 +177,7 @@ namespace boost
    }


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

    void thread::start_thread()
@@ -205,42 +187,7 @@ namespace boost
        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;
-              }
-          }
+            boost::throw_exception(thread_resource_error());
        }
    }

@@ -256,10 +203,6 @@ namespace boost

    void thread::join()
    {
-        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)
        {
@@ -301,12 +244,8 @@ namespace boost
        }
    }

-    bool thread::do_try_join_until(struct timespec const &timeout)
+    bool thread::timed_join(system_time const& wait_until)
    {
-        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)
        {
@@ -316,7 +255,7 @@ namespace boost
                unique_lock<mutex> lock(local_thread_info->data_mutex);
                while(!local_thread_info->done)
                {
-                    if(!local_thread_info->done_condition.do_timed_wait(lock,timeout))
+                    if(!local_thread_info->done_condition.timed_wait(lock,wait_until))
                    {
                        return false;
                    }
@@ -352,7 +291,7 @@ namespace boost
        return true;
    }

-    bool thread::joinable() const BOOST_NOEXCEPT
+    bool thread::joinable() const
    {
        return (get_thread_info)();
    }
@@ -422,34 +361,7 @@ namespace boost
            }
        }

-#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
+        void yield()
        {
 #   if defined(BOOST_HAS_SCHED_YIELD)
            BOOST_VERIFY(!sched_yield());
@@ -462,7 +374,8 @@ namespace boost
 #   endif
        }
    }
-    unsigned thread::hardware_concurrency() BOOST_NOEXCEPT
+
+    unsigned thread::hardware_concurrency()
    {
 #if defined(PTW32_VERSION) || defined(__hpux)
        return pthread_num_processors_np();
@@ -480,7 +393,7 @@ namespace boost
 #endif
    }

-    thread::id thread::get_id() const BOOST_NOEXCEPT
+    thread::id thread::get_id() const
    {
        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
        if(local_thread_info)
@@ -540,7 +453,7 @@ namespace boost

    namespace this_thread
    {
-        thread::id get_id() BOOST_NOEXCEPT
+        thread::id get_id()
        {
            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());
--- a/src/win32/thread.cpp
+++ b/src/win32/thread.cpp
@@ -27,33 +27,32 @@ namespace boost
    namespace
    {
        boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
-        #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;
+        DWORD current_thread_tls_key=0;

        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_index);
+			#if defined(UNDER_CE)
+				// Windows CE does not define the TLS_OUT_OF_INDEXES constant.
+				BOOST_ASSERT(current_thread_tls_key!=0xFFFFFFFF);
+			#else
+				BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);
+			#endif
        }

        void cleanup_tls_key()
        {
-            if(current_thread_tls_key!=tls_out_of_index)
+            if(current_thread_tls_key)
            {
                TlsFree(current_thread_tls_key);
-                current_thread_tls_key=tls_out_of_index;
+                current_thread_tls_key=0;
            }
        }

        detail::thread_data_base* get_current_thread_data()
        {
-            if(current_thread_tls_key==tls_out_of_index)
+            if(!current_thread_tls_key)
            {
                return 0;
            }
@@ -63,7 +62,7 @@ namespace boost
        void set_current_thread_data(detail::thread_data_base* new_data)
        {
            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
-            if(current_thread_tls_key!=tls_out_of_index)
+            if(current_thread_tls_key)
                BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
            else
                boost::throw_exception(thread_resource_error());
@@ -194,7 +193,7 @@ namespace boost
        }
    }

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

    void thread::start_thread()
@@ -209,19 +208,6 @@ namespace boost
        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)
    {}
@@ -276,22 +262,18 @@ namespace boost
        detach();
    }

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

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

    void thread::join()
    {
-        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)
        {
@@ -302,10 +284,6 @@ namespace boost

    bool thread::timed_join(boost::system_time const& wait_until)
    {
-        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)
        {
@@ -318,26 +296,6 @@ namespace boost
        return true;
    }

-#ifdef BOOST_THREAD_USES_CHRONO
-    bool thread::do_try_join_for(chrono::milliseconds const &rel_time_in_milliseconds) {
-      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,rel_time_in_milliseconds.count()))
-          {
-              return false;
-          }
-          release_handle();
-      }
-      return true;
-
-    }
-#endif
-
    void thread::detach()
    {
        release_handle();
@@ -363,7 +321,7 @@ namespace boost
        return local_thread_info.get() && (detail::win32::WaitForSingleObject(local_thread_info->interruption_handle,0)==0);
    }

-    unsigned thread::hardware_concurrency() BOOST_NOEXCEPT
+    unsigned thread::hardware_concurrency()
    {
        SYSTEM_INFO info={{0}};
        GetSystemInfo(&info);
@@ -533,7 +491,7 @@ namespace boost
            return false;
        }

-        thread::id get_id() BOOST_NOEXCEPT
+        thread::id get_id()
        {
            return thread::id(get_or_make_current_thread_data());
        }
@@ -557,7 +515,7 @@ namespace boost
            return get_current_thread_data() && (detail::win32::WaitForSingleObject(get_current_thread_data()->interruption_handle,0)==0);
        }

-        void yield() BOOST_NOEXCEPT
+        void yield()
        {
            detail::win32::Sleep(0);
        }
--- 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,38 +25,16 @@ 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 ]
@@ -78,7 +56,6 @@ rule thread-compile-fail-V2 ( sources : reqs * : name )
          [ 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 ]
          [ thread-run test_lock_concept.cpp ]
          [ thread-run test_generic_locks.cpp ]
          [ thread-run test_futures.cpp ]
@@ -89,192 +66,25 @@ rule thread-compile-fail-V2 ( sources : reqs * : name )

    #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_2501.cpp ]
+          [ thread-run test_4521.cpp ]
+          [ thread-run test_4648.cpp ]
+          [ thread-run test_4882.cpp ]
          [ thread-run test_5351.cpp ]
          [ thread-run test_5502.cpp ]
+          [ thread-run test_5542_1.cpp ]
+          [ thread-run test_5542_2.cpp ]
+          [ thread-run test_5542_3.cpp ]
+          [ thread-run test_6130.cpp ]
+          [ thread-run test_6174.cpp ]
    ;

-
-
-    #explicit conditions ;
-    test-suite conditions
-    :
-          [ thread-compile-fail-V2 ./sync/conditions/condition_variable/assign_fail.cpp : : conditions__condition_variable__assign_fail ]
-          [ thread-compile-fail-V2 ./sync/conditions/condition_variable/copy_fail.cpp : : conditions__condition_variable__copy_fail ]
-          [ thread-run2 ./sync/conditions/condition_variable/default_pass.cpp : conditions__condition_variable__default_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable/dtor_pass.cpp : conditions__condition_variable__dtor_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable/native_handle_pass.cpp : conditions__condition_variable__native_handle_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable/wait_for_pass.cpp : conditions__condition_variable__wait_for_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable/wait_for_pred_pass.cpp : conditions__condition_variable__wait_for_pred_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable/wait_until_pass.cpp : conditions__condition_variable__wait_until_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable/wait_until_pred_pass.cpp : conditions__condition_variable__wait_until_pred_pass ]
-
-          [ thread-compile-fail-V2 ./sync/conditions/condition_variable_any/assign_fail.cpp : : conditions__condition_variable_any__assign_fail ]
-          [ thread-compile-fail-V2 ./sync/conditions/condition_variable_any/copy_fail.cpp : : conditions__condition_variable_any__copy_fail ]
-          [ thread-run2 ./sync/conditions/condition_variable_any/default_pass.cpp : conditions__condition_variable_any__default_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable_any/dtor_pass.cpp : conditions__condition_variable_any__dtor_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable_any/wait_for_pass.cpp : conditions__condition_variable_any__wait_for_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable_any/wait_for_pred_pass.cpp : conditions__condition_variable_any__wait_for_pred_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable_any/wait_until_pass.cpp : conditions__condition_variable_any__wait_until_pass ]
-          [ thread-run2 ./sync/conditions/condition_variable_any/wait_until_pred_pass.cpp : conditions__condition_variable_any__wait_until_pred_pass ]
-          [ thread-run2 ./sync/conditions/cv_status/cv_status_pass.cpp : conditions__cv_status__cv_status_pass ]
-    ;
-
-    #explicit futures ;
-    test-suite futures
-    :
-    #      [ thread-run2 ./sync/futures/async/async_pass.cpp : futures__async__async_pass ]
-          [ thread-run2 ./sync/futures/promise/default_pass.cpp : futures__promise__default_pass ]
-          [ thread-run2 ./sync/futures/promise/dtor_pass.cpp : futures__promise__dtor_pass ]
-          [ thread-run2 ./sync/futures/promise/get_future_pass.cpp : futures__promise__get_future_pass ]
-    ;
-
-    explicit tt ;
-    test-suite tt
-    :
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp : xmutual_exclusion__locks__unique_lock__cons__try_to_lock_pass ]
-    ;
-
-    #explicit mutual_exclusion ;
-    test-suite mutual_exclusion
-    :
-
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp : : mutual_exclusion__locks__unique_lock__cons__copy_assign_fail ]
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp : : mutual_exclusion__locks__unique_lock__cons__copy_ctor_fail ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp : mutual_exclusion__locks__unique_lock__cons__adopt_lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp : mutual_exclusion__locks__unique_lock__cons__default_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp : mutual_exclusion__locks__unique_lock__cons__defer_lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp : mutual_exclusion__locks__unique_lock__cons__duration_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp : mutual_exclusion__locks__unique_lock__cons__move_assign_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp : mutual_exclusion__locks__unique_lock__cons__move_ctor_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp : mutual_exclusion__locks__unique_lock__cons__mutex_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp : mutual_exclusion__locks__unique_lock__cons__time_point_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp : mutual_exclusion__locks__unique_lock__cons__try_to_lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp : mutual_exclusion__locks__unique_lock__locking__lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp : mutual_exclusion__locks__unique_lock__locking__try_lock_for_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp : mutual_exclusion__locks__unique_lock__locking__try_lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp : mutual_exclusion__locks__unique_lock__locking__try_lock_until_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/unlock_pass.cpp : mutual_exclusion__locks__unique_lock__locking__unlock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/member_swap_pass.cpp : mutual_exclusion__locks__unique_lock__mod__member_swap_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/non_member_swap_pass.cpp : mutual_exclusion__locks__unique_lock__mod__non_member_swap_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/release_pass.cpp : mutual_exclusion__locks__unique_lock__mod__release_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/mutex_pass.cpp : mutual_exclusion__locks__unique_lock__obs__mutex_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/op_bool_pass.cpp : mutual_exclusion__locks__unique_lock__obs__op_bool_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/owns_lock_pass.cpp : mutual_exclusion__locks__unique_lock__obs__owns_lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/types_pass.cpp : mutual_exclusion__locks__unique_lock__types_pass ]
-
-          #[ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp : : mutual_exclusion__locks__shared_lock__cons__copy_assign_fail ]
-          #[ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp : : mutual_exclusion__locks__shared_lock__cons__copy_ctor_fail ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp : mutual_exclusion__locks__shared_lock__cons__adopt_lock_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp : mutual_exclusion__locks__shared_lock__cons__default_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp : mutual_exclusion__locks__shared_lock__cons__defer_lock_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp : mutual_exclusion__locks__shared_lock__cons__duration_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp : mutual_exclusion__locks__shared_lock__cons__move_assign_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp : mutual_exclusion__locks__shared_lock__cons__move_ctor_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp : mutual_exclusion__locks__shared_lock__cons__mutex_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp : mutual_exclusion__locks__shared_lock__cons__time_point_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp : mutual_exclusion__locks__shared_lock__cons__try_to_lock_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp : mutual_exclusion__locks__shared_lock__locking__lock_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp : mutual_exclusion__locks__shared_lock__locking__try_lock_for_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp : mutual_exclusion__locks__shared_lock__locking__try_lock_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp : mutual_exclusion__locks__shared_lock__locking__try_lock_until_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp : mutual_exclusion__locks__shared_lock__locking__unlock_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp : mutual_exclusion__locks__shared_lock__mod__member_swap_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp : mutual_exclusion__locks__shared_lock__mod__non_member_swap_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp : mutual_exclusion__locks__shared_lock__mod__release_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp : mutual_exclusion__locks__shared_lock__obs__mutex_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp : mutual_exclusion__locks__shared_lock__obs__op_bool_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp : mutual_exclusion__locks__shared_lock__obs__owns_lock_pass ]
-
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/mutex/assign_fail.cpp : : mutual_exclusion__mutex__assign_fail ]
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/mutex/copy_fail.cpp : : mutual_exclusion__mutex__copy_fail ]
-          [ thread-run2 ./sync/mutual_exclusion/mutex/default_pass.cpp : mutual_exclusion__mutex__default_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/mutex/lock_pass.cpp : mutual_exclusion__mutex__lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/mutex/native_handle_pass.cpp : mutual_exclusion__mutex__native_handle_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/mutex/try_lock_pass.cpp : mutual_exclusion__mutex__try_lock_pass ]
-
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_mutex/assign_fail.cpp : : mutual_exclusion__recursive_mutex__assign_fail ]
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_mutex/copy_fail.cpp : : mutual_exclusion__recursive_mutex__copy_fail ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/default_pass.cpp : mutual_exclusion__recursive_mutex__default_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/lock_pass.cpp : mutual_exclusion__recursive_mutex__lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/native_handle_pass.cpp : mutual_exclusion__recursive_mutex__native_handle_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp : mutual_exclusion__recursive_mutex__try_lock_pass ]
-
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_timed_mutex/assign_fail.cpp : : mutual_exclusion__recursive_timed_mutex__assign_fail ]
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_timed_mutex/copy_fail.cpp : : mutual_exclusion__recursive_timed_mutex__copy_fail ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/default_pass.cpp : mutual_exclusion__recursive_timed_mutex__default_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp : mutual_exclusion__recursive_timed_mutex__lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/native_handle_pass.cpp : mutual_exclusion__recursive_timed_mutex__native_handle_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp : mutual_exclusion__recursive_timed_mutex__try_lock_for_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp : mutual_exclusion__recursive_timed_mutex__try_lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp : mutual_exclusion__recursive_timed_mutex__try_lock_until_pass ]
-
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/timed_mutex/assign_fail.cpp : : mutual_exclusion__timed_mutex__assign_fail ]
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/timed_mutex/copy_fail.cpp : : mutual_exclusion__timed_mutex__copy_fail ]
-          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/default_pass.cpp : mutual_exclusion__timed_mutex__default_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/lock_pass.cpp : mutual_exclusion__timed_mutex__lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/native_handle_pass.cpp : mutual_exclusion__timed_mutex__native_handle_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp : mutual_exclusion__timed_mutex__try_lock_for_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp : mutual_exclusion__timed_mutex__try_lock_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp : mutual_exclusion__timed_mutex__try_lock_until_pass ]
-
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/shared_mutex/assign_fail.cpp : : mutual_exclusion__shared_mutex__assign_fail ]
-          [ thread-compile-fail-V2 ./sync/mutual_exclusion/shared_mutex/copy_fail.cpp : : mutual_exclusion__shared_mutex__copy_fail ]
-          [ thread-run2 ./sync/mutual_exclusion/shared_mutex/default_pass.cpp : mutual_exclusion__shared_mutex__default_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/shared_mutex/lock_pass.cpp : mutual_exclusion__shared_mutex__lock_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp : mutual_exclusion__shared_mutex__try_lock_for_pass ]
-          [ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp : mutual_exclusion__shared_mutex__try_lock_pass ]
-          #[ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp : mutual_exclusion__shared_mutex__try_lock_until_pass ]
-
-    ;
-
-    #explicit this_thread ;
-    test-suite this_thread
-    :
-          [ thread-run2 ./threads/this_thread/get_id/get_id_pass.cpp : this_thread__get_id__get_id_pass ]
-          [ thread-run2 ./threads/this_thread/sleep_for/sleep_for_pass.cpp : this_thread__sleep_for__sleep_for_pass ]
-          [ thread-run2 ./threads/this_thread/sleep_until/sleep_until_pass.cpp : this_thread__sleep_until__sleep_until_pass ]
-    ;
-
-    #explicit thread ;
-    test-suite thread
-    :
-          [ thread-compile-fail-V2 ./threads/thread/assign/copy_fail.cpp : : thread__assign__copy_fail ]
-          [ thread-run2 ./threads/thread/assign/move_pass.cpp : thread__assign__move_pass ]
-          [ thread-compile-fail-V2 ./threads/thread/constr/copy_fail.cpp : : thread__constr__copy_fail ]
-          [ thread-run2 ./threads/thread/constr/default_pass.cpp : thread__constr__default_pass ]
-          [ thread-run2 ./threads/thread/constr/F_pass.cpp : thread__constr__F_pass ]
-          [ thread-run2 ./threads/thread/constr/Frvalue_pass.cpp : thread__constr__Frvalue_pass ]
-          #[ thread-run2 ./threads/thread/constr/FrvalueArgs_pass.cpp : thread__constr__FrvalueArgs_pass ]
-          [ thread-run2 ./threads/thread/constr/move_pass.cpp : thread__constr__move_pass ]
-          [ thread-run2 ./threads/thread/destr/dtor_pass.cpp : thread__destr__dtor_pass ]
-          [ thread-run2 ./threads/thread/id/hash_pass.cpp : thread__id__hash_pass ]
-          [ thread-run2 ./threads/thread/members/detach_pass.cpp : thread__members__detach_pass ]
-          [ thread-run2 ./threads/thread/members/get_id_pass.cpp : thread__members__get_id_pass ]
-          [ thread-run2 ./threads/thread/members/join_pass.cpp : thread__members__join_pass ]
-          [ thread-run2 ./threads/thread/members/joinable_pass.cpp : thread__members__joinable_pass ]
-          [ thread-run2 ./threads/thread/members/native_handle_pass.cpp : thread__members__native_handle_pass ]
-          [ thread-run2 ./threads/thread/members/swap_pass.cpp : thread__members__swap_pass ]
-          [ thread-run2 ./threads/thread/non_members/swap_pass.cpp : thread__non_members__swap_pass ]
-          [ thread-run2 ./threads/thread/static/hardware_concurrency_pass.cpp : thread__static__hardware_concurrency_pass ]
-    ;
 }
--- a/test/sync/conditions/condition_variable/assign_fail.cpp
+++ b/test/sync/conditions/condition_variable/assign_fail.cpp
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,95 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,108 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,122 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,28 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,99 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,110 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,112 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,126 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
@@ -1,184 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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/promise/copy_asign_fail.cpp
+++ b/test/sync/futures/promise/copy_asign_fail.cpp
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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>
-
-#include <boost/thread/future.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-
-int main()
-{
-
-  {
-      boost::promise<int> p;
-      boost::future<int> f = p.get_future();
-      BOOST_TEST(f.valid());
-  }
-  {
-      boost::promise<int&> p;
-      boost::future<int&> f = p.get_future();
-      BOOST_TEST(f.valid());
-  }
-  {
-      boost::promise<void> p;
-      boost::future<void> f = p.get_future();
-      BOOST_TEST(f.valid());
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/futures/promise/default_pass.cpp
+++ b/test/sync/futures/promise/default_pass.cpp
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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()
-{
-
-  {
-      boost::promise<int> p;
-      boost::future<int> f = p.get_future();
-      BOOST_TEST(f.valid());
-  }
-  {
-      boost::promise<int&> p;
-      boost::future<int&> f = p.get_future();
-      BOOST_TEST(f.valid());
-  }
-  {
-      boost::promise<void> p;
-      boost::future<void> f = p.get_future();
-      BOOST_TEST(f.valid());
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/futures/promise/dtor_pass.cpp
+++ b/test/sync/futures/promise/dtor_pass.cpp
@@ -1,116 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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()
-{
-  {
-      typedef int T;
-      boost::future<T> f;
-      {
-          boost::promise<T> p;
-          f = p.get_future();
-          p.set_value(3);
-      }
-      BOOST_TEST(f.get() == 3);
-  }
-  {
-      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));
-      }
-  }
-
-  {
-      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);
-  }
-  {
-      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));
-      }
-  }
-
-  {
-      typedef void T;
-      boost::future<T> f;
-      {
-          boost::promise<T> p;
-          f = p.get_future();
-          p.set_value();
-      }
-      f.get();
-      BOOST_TEST(true);
-  }
-  {
-      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
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// shared_lock(mutex_type& m, adopt_lock_t);
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-
-int main()
-{
-  boost::shared_mutex m;
-  m.lock();
-  boost::shared_lock<boost::shared_mutex> lk(m, boost::adopt_lock);
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == true);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// shared_lock& operator=(shared_lock const&) = delete;
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m0;
-boost::shared_mutex m1;
-
-int main()
-{
-  boost::shared_lock<boost::shared_mutex> lk0(m0);
-  boost::shared_lock<boost::shared_mutex> lk1(m1);
-  lk1 = lk0;
-  BOOST_TEST(lk1.mutex() == &m0);
-  BOOST_TEST(lk1.owns_lock() == true);
-  BOOST_TEST(lk0.mutex() == 0);
-  BOOST_TEST(lk0.owns_lock() == false);
-
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// shared_lock(shared_lock const&) = delete;
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m0;
-boost::shared_mutex m1;
-
-int main()
-{
-  boost::shared_lock<boost::shared_mutex> lk0(m0);
-  boost::shared_lock<boost::shared_mutex> lk1 = lk0;
-  BOOST_TEST(lk1.mutex() == &m1);
-  BOOST_TEST(lk1.owns_lock() == true);
-  BOOST_TEST(lk0.mutex() == 0);
-  BOOST_TEST(lk0.owns_lock() == false);
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// shared_lock(shared_lock const&) = delete;
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-int main()
-{
-  boost::shared_lock<boost::shared_mutex> ul;
-  BOOST_TEST(!ul.owns_lock());
-  BOOST_TEST(ul.mutex() == 0);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// shared_lock(mutex_type& m, adopt_lock_t);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-int main()
-{
-  boost::shared_mutex m;
-  m.lock();
-  boost::shared_lock<boost::shared_mutex> lk(m, boost::defer_lock);
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == false);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// template <class Rep, class Period>
-//   shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/chrono/chrono_io.hpp>
-
-boost::shared_mutex m;
-
-typedef boost::chrono::steady_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f1()
-{
-  time_point t0 = Clock::now();
-  boost::shared_lock<boost::shared_mutex> lk(m, ms(300));
-  BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < ns(5000000)); // within 5ms
-}
-
-void f2()
-{
-  time_point t0 = Clock::now();
-  boost::shared_lock<boost::shared_mutex> lk(m, ms(250));
-  BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(5000000)+ms(1000)); // within 5ms
-}
-
-int main()
-{
-  {
-    m.lock();
-    boost::thread t(f1);
-    boost::this_thread::sleep_for(ms(250));
-    m.unlock();
-    t.join();
-  }
-  {
-    m.lock();
-    boost::thread t(f2);
-    boost::this_thread::sleep_for(ms(300));
-    m.unlock();
-    t.join();
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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/shared_mutex.hpp>
-
-// template <class Mutex> class shared_lock;
-
-// shared_lock(shared_lock const&) = delete;
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m0;
-boost::shared_mutex m1;
-
-int main()
-{
-  {
-    boost::shared_lock<boost::shared_mutex> lk0(m0);
-    boost::shared_lock<boost::shared_mutex> lk1(m1);
-    lk1 = boost::move(lk0);
-    BOOST_TEST(lk1.mutex() == &m0);
-    BOOST_TEST(lk1.owns_lock() == true);
-    BOOST_TEST(lk0.mutex() == 0);
-    BOOST_TEST(lk0.owns_lock() == false);
-  }
-
-
-  {
-
-    boost::shared_lock<boost::shared_mutex> lk1;
-    lk1 = boost::shared_lock<boost::shared_mutex>(m0);
-    BOOST_TEST(lk1.mutex() == &m0);
-    BOOST_TEST(lk1.owns_lock() == true);
-  }
-  return boost::report_errors();
-
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// shared_lock& operator=(shared_lock&& u);
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m;
-
-int main()
-{
-  {
-  boost::shared_lock<boost::shared_mutex> lk0(m);
-  boost::shared_lock<boost::shared_mutex> lk( (boost::move(lk0)));
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == true);
-  BOOST_TEST(lk0.mutex() == 0);
-  BOOST_TEST(lk0.owns_lock() == false);
-  }
-  {
-  boost::shared_lock<boost::shared_mutex> lk( (boost::shared_lock<boost::shared_mutex>(m)));
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == true);
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// explicit shared_lock(Mutex& m);
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m;
-
-typedef boost::chrono::system_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f()
-{
-  time_point t0 = Clock::now();
-  time_point t1;
-  {
-    boost::shared_lock<boost::shared_mutex> ul(m);
-    t1 = Clock::now();
-  }
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  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/shared_lock/cons/time_point_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp
@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// template <class Clock, class Duration>
-//   shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m;
-
-typedef boost::chrono::steady_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f1()
-{
-  time_point t0 = Clock::now();
-  boost::shared_lock<boost::shared_mutex> lk(m, Clock::now() + ms(300));
-  BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < ns(50000000)); // within 50ms
-}
-
-void f2()
-{
-  time_point t0 = Clock::now();
-  boost::shared_lock<boost::shared_mutex> lk(m, Clock::now() + ms(250));
-  BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(5000000)+ms(1000)); // within 5ms
-}
-
-int main()
-{
-  {
-    m.lock();
-    boost::thread t(f1);
-    boost::this_thread::sleep_for(ms(250));
-    m.unlock();
-    t.join();
-  }
-  {
-    m.lock();
-    boost::thread t(f2);
-    boost::this_thread::sleep_for(ms(300));
-    m.unlock();
-    t.join();
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp
@@ -1,72 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// shared_lock(mutex_type& m, try_to_lock_t);
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m;
-
-typedef boost::chrono::system_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f()
-{
-  time_point t0 = Clock::now();
-  {
-    boost::shared_lock<boost::shared_mutex> lk(m, boost::try_to_lock);
-    BOOST_TEST(lk.owns_lock() == false);
-  }
-  {
-    boost::shared_lock<boost::shared_mutex> lk(m, boost::try_to_lock);
-    BOOST_TEST(lk.owns_lock() == false);
-  }
-  {
-    boost::shared_lock<boost::shared_mutex> lk(m, boost::try_to_lock);
-    BOOST_TEST(lk.owns_lock() == false);
-  }
-  while (true)
-  {
-    boost::shared_lock<boost::shared_mutex> lk(m, boost::try_to_lock);
-    if (lk.owns_lock()) break;
-  }
-  time_point t1 = Clock::now();
-  //m.unlock();
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(50000000)+ms(1000)); // within 50ms
-}
-
-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/shared_lock/locking/lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// void lock();
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <iostream>
-
-boost::shared_mutex m;
-
-typedef boost::chrono::system_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f()
-{
-  boost::shared_lock < boost::shared_mutex > lk(m, boost::defer_lock);
-  time_point t0 = Clock::now();
-  lk.lock();
-  time_point t1 = Clock::now();
-  BOOST_TEST(lk.owns_lock() == true);
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(2500000)+ms(1000)); // within 2.5ms
-  try
-  {
-    lk.lock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
-  }
-  lk.unlock();
-  lk.release();
-  try
-  {
-    lk.lock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-}
-
-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/shared_lock/locking/try_lock_for_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp
@@ -1,78 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// template <class Rep, class Period>
-//   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
-
-#include <boost/thread/locks.hpp>
-//#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-bool try_lock_for_called = false;
-
-typedef boost::chrono::milliseconds ms;
-
-struct shared_mutex
-{
-  template <class Rep, class Period>
-  bool try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time)
-  {
-    BOOST_TEST(rel_time == ms(5));
-    try_lock_for_called = !try_lock_for_called;
-    return try_lock_for_called;
-  }
-  void unlock_shared()
-  {
-  }
-};
-
-shared_mutex m;
-
-int main()
-{
-  boost::shared_lock<shared_mutex> lk(m, boost::defer_lock);
-  BOOST_TEST(lk.try_lock_for(ms(5)) == true);
-  BOOST_TEST(try_lock_for_called == true);
-  BOOST_TEST(lk.owns_lock() == true);
-  try
-  {
-    lk.try_lock_for(ms(5));
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
-  }
-  lk.unlock();
-  BOOST_TEST(lk.try_lock_for(ms(5)) == false);
-  BOOST_TEST(try_lock_for_called == false);
-  BOOST_TEST(lk.owns_lock() == false);
-  lk.release();
-  try
-  {
-    lk.try_lock_for(ms(5));
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// template <class Rep, class Period>
-//   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
-
-#include <boost/thread/locks.hpp>
-//#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-bool try_lock_called = false;
-
-struct shared_mutex
-{
-  bool try_lock_shared()
-  {
-    try_lock_called = !try_lock_called;
-    return try_lock_called;
-  }
-  void unlock_shared()
-  {
-  }
-};
-
-shared_mutex m;
-
-int main()
-{
-  boost::shared_lock<shared_mutex> lk(m, boost::defer_lock);
-  BOOST_TEST(lk.try_lock() == true);
-  BOOST_TEST(try_lock_called == true);
-  BOOST_TEST(lk.owns_lock() == true);
-  try
-  {
-    lk.try_lock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
-  }
-  lk.unlock();
-  BOOST_TEST(lk.try_lock() == false);
-  BOOST_TEST(try_lock_called == false);
-  BOOST_TEST(lk.owns_lock() == false);
-  lk.release();
-  try
-  {
-    lk.try_lock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp
@@ -1,76 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// template <class Clock, class Duration>
-//   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-bool try_lock_until_called = false;
-
-struct shared_mutex
-{
-  template <class Clock, class Duration>
-  bool try_lock_shared_until(const boost::chrono::time_point<Clock, Duration>& abs_time)
-  {
-    typedef boost::chrono::milliseconds ms;
-    BOOST_TEST(Clock::now() - abs_time < ms(5));
-    try_lock_until_called = !try_lock_until_called;
-    return try_lock_until_called;
-  }
-  void unlock_shared()
-  {
-  }
-};
-
-shared_mutex m;
-
-int main()
-{
-  typedef boost::chrono::steady_clock Clock;
-  boost::shared_lock<shared_mutex> lk(m, boost::defer_lock);
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == true);
-  BOOST_TEST(try_lock_until_called == true);
-  BOOST_TEST(lk.owns_lock() == true);
-  try
-  {
-    lk.try_lock_until(Clock::now());
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
-  }
-  lk.unlock();
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == false);
-  BOOST_TEST(try_lock_until_called == false);
-  BOOST_TEST(lk.owns_lock() == false);
-  lk.release();
-  try
-  {
-    lk.try_lock_until(Clock::now());
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-  return boost::report_errors();
-}
--- a/test/sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp
@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// template <class Rep, class Period>
-//   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
-
-#include <boost/thread/locks.hpp>
-//#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-bool unlock_called = false;
-
-struct shared_mutex
-{
-  void lock_shared()
-  {
-  }
-  void unlock_shared()
-  {
-    unlock_called = true;
-  }
-};
-
-shared_mutex m;
-
-int main()
-{
-  boost::shared_lock<shared_mutex> lk(m);
-  lk.unlock();
-  BOOST_TEST(unlock_called == true);
-  BOOST_TEST(lk.owns_lock() == false);
-  try
-  {
-    lk.unlock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-  lk.release();
-  try
-  {
-    lk.unlock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// void swap(shared_lock& u);
-
-#include <boost/thread/locks.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-struct shared_mutex
-{
-  void lock_shared()
-  {
-  }
-  void unlock_shared()
-  {
-  }
-};
-
-shared_mutex m;
-
-int main()
-{
-  boost::shared_lock<shared_mutex> lk1(m);
-  boost::shared_lock<shared_mutex> lk2;
-  lk1.swap(lk2);
-  BOOST_TEST(lk1.mutex() == 0);
-  BOOST_TEST(lk1.owns_lock() == false);
-  BOOST_TEST(lk2.mutex() == &m);
-  BOOST_TEST(lk2.owns_lock() == true);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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>
-//   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y);
-
-#include <boost/thread/locks.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-struct shared_mutex
-{
-  void lock_shared()
-  {
-  }
-  void unlock_shared()
-  {
-  }
-};
-
-shared_mutex m;
-
-int main()
-{
-  boost::shared_lock<shared_mutex> lk1(m);
-  boost::shared_lock<shared_mutex> lk2;
-  swap(lk1, lk2);
-  BOOST_TEST(lk1.mutex() == 0);
-  BOOST_TEST(lk1.owns_lock() == false);
-  BOOST_TEST(lk2.mutex() == &m);
-  BOOST_TEST(lk2.owns_lock() == true);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// void Mutex* release();
-
-#include <boost/thread/locks.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-struct shared_mutex
-{
-  static int lock_count;
-  static int unlock_count;
-  void lock_shared()
-  {
-    ++lock_count;
-  }
-  void unlock_shared()
-  {
-    ++unlock_count;
-  }
-};
-
-int shared_mutex::lock_count = 0;
-int shared_mutex::unlock_count = 0;
-
-shared_mutex m;
-
-int main()
-{
-  boost::shared_lock<shared_mutex> lk(m);
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == true);
-  BOOST_TEST(shared_mutex::lock_count == 1);
-  BOOST_TEST(shared_mutex::unlock_count == 0);
-  BOOST_TEST(lk.release() == &m);
-  BOOST_TEST(lk.mutex() == 0);
-  BOOST_TEST(lk.owns_lock() == false);
-  BOOST_TEST(shared_mutex::lock_count == 1);
-  BOOST_TEST(shared_mutex::unlock_count == 0);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// Mutex *mutex() const;
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m;
-
-int main()
-{
-  boost::shared_lock<boost::shared_mutex> lk0;
-  BOOST_TEST(lk0.mutex() == 0);
-  boost::shared_lock<boost::shared_mutex> lk1(m);
-  BOOST_TEST(lk1.mutex() == &m);
-  lk1.unlock();
-  BOOST_TEST(lk1.mutex() == &m);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// explicit operator bool() const;
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m;
-
-int main()
-{
-  boost::shared_lock < boost::shared_mutex > lk0;
-  BOOST_TEST(bool(lk0) == false);
-  boost::shared_lock < boost::shared_mutex > lk1(m);
-  BOOST_TEST(bool(lk1) == true);
-  lk1.unlock();
-  BOOST_TEST(bool(lk1) == false);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 shared_lock;
-
-// bool owns_lock() const;
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::shared_mutex m;
-
-int main()
-{
-  boost::shared_lock<boost::shared_mutex> lk0;
-  BOOST_TEST(lk0.owns_lock() == false);
-  boost::shared_lock<boost::shared_mutex> lk1(m);
-  BOOST_TEST(lk1.owns_lock() == true);
-  lk1.unlock();
-  BOOST_TEST(lk1.owns_lock() == false);
-
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// unique_lock(mutex_type& m, adopt_lock_t);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-
-int main()
-{
-  boost::mutex m;
-  m.lock();
-  boost::unique_lock<boost::mutex> lk(m, boost::adopt_lock);
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == true);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp
@@ -1,39 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// unique_lock& operator=(unique_lock 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::unique_lock<boost::mutex> lk0(m0);
-  boost::unique_lock<boost::mutex> lk1(m1);
-  lk1 = lk0;
-  BOOST_TEST(lk1.mutex() == &m0);
-  BOOST_TEST(lk1.owns_lock() == true);
-  BOOST_TEST(lk0.mutex() == 0);
-  BOOST_TEST(lk0.owns_lock() == false);
-
-}
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// unique_lock(unique_lock 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::unique_lock<boost::mutex> lk0(m0);
-  boost::unique_lock<boost::mutex> lk1 = lk0;
-  BOOST_TEST(lk1.mutex() == &m1);
-  BOOST_TEST(lk1.owns_lock() == true);
-  BOOST_TEST(lk0.mutex() == 0);
-  BOOST_TEST(lk0.owns_lock() == false);
-}
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// unique_lock(unique_lock const&) = delete;
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-int main()
-{
-  boost::unique_lock<boost::mutex> ul;
-  BOOST_TEST(!ul.owns_lock());
-  BOOST_TEST(ul.mutex() == 0);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// unique_lock(mutex_type& m, adopt_lock_t);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-int main()
-{
-  boost::mutex m;
-  m.lock();
-  boost::unique_lock<boost::mutex> lk(m, boost::defer_lock);
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == false);
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp
@@ -1,82 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// template <class Rep, class Period>
-//   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/chrono/chrono_io.hpp>
-
-#if defined BOOST_THREAD_USES_CHRONO
-
-boost::timed_mutex m;
-
-typedef boost::chrono::steady_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f1()
-{
-  time_point t0 = Clock::now();
-  boost::unique_lock<boost::timed_mutex> lk(m, ms(300));
-  BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(5000000)+ms(1000)); // within 5ms
-}
-
-void f2()
-{
-  time_point t0 = Clock::now();
-  boost::unique_lock<boost::timed_mutex> lk(m, ms(250));
-  BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(5000000)+ms(1000)); // within 5ms
-}
-
-int main()
-{
-  {
-    m.lock();
-    boost::thread t(f1);
-    boost::this_thread::sleep_for(ms(250));
-    m.unlock();
-    t.join();
-  }
-  {
-    m.lock();
-    boost::thread t(f2);
-    boost::this_thread::sleep_for(ms(300));
-    m.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/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp
@@ -1,52 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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/mutex.hpp>
-
-// template <class Mutex> class unique_lock;
-
-// unique_lock(unique_lock 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::unique_lock<boost::mutex> lk0(m0);
-    boost::unique_lock<boost::mutex> lk1(m1);
-    lk1 = boost::move(lk0);
-    BOOST_TEST(lk1.mutex() == &m0);
-    BOOST_TEST(lk1.owns_lock() == true);
-    BOOST_TEST(lk0.mutex() == 0);
-    BOOST_TEST(lk0.owns_lock() == false);
-  }
-
-
-  {
-
-    boost::unique_lock<boost::mutex> lk1;
-    lk1 = boost::unique_lock<boost::mutex>(m0);
-    BOOST_TEST(lk1.mutex() == &m0);
-    BOOST_TEST(lk1.owns_lock() == true);
-  }
-  return boost::report_errors();
-
-}
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// unique_lock& operator=(unique_lock&& u);
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-boost::mutex m;
-
-int main()
-{
-  {
-  boost::unique_lock<boost::mutex> lk0(m);
-  boost::unique_lock<boost::mutex> lk( (boost::move(lk0)));
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == true);
-  BOOST_TEST(lk0.mutex() == 0);
-  BOOST_TEST(lk0.owns_lock() == false);
-  }
-  {
-  boost::unique_lock<boost::mutex> lk( (boost::unique_lock<boost::mutex>(m)));
-  BOOST_TEST(lk.mutex() == &m);
-  BOOST_TEST(lk.owns_lock() == true);
-  }
-
-  return boost::report_errors();
-}
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// explicit unique_lock(Mutex& m);
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-#if defined BOOST_THREAD_USES_CHRONO
-
-boost::mutex m;
-
-typedef boost::chrono::system_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f()
-{
-  time_point t0 = Clock::now();
-  time_point t1;
-  {
-    boost::unique_lock<boost::mutex> ul(m);
-    t1 = Clock::now();
-  }
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  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();
-}
-
-#else
-#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
-#endif
-
--- a/test/sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp
@@ -1,80 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// template <class Clock, class Duration>
-//   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-#if defined BOOST_THREAD_USES_CHRONO
-
-boost::timed_mutex m;
-
-typedef boost::chrono::steady_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f1()
-{
-  time_point t0 = Clock::now();
-  boost::unique_lock<boost::timed_mutex> lk(m, Clock::now() + ms(300));
-  BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < ns(50000000)); // within 50ms
-}
-
-void f2()
-{
-  time_point t0 = Clock::now();
-  boost::unique_lock<boost::timed_mutex> lk(m, Clock::now() + ms(250));
-  BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(5000000)+ms(1000)); // within 5ms
-}
-
-int main()
-{
-  {
-    m.lock();
-    boost::thread t(f1);
-    boost::this_thread::sleep_for(ms(250));
-    m.unlock();
-    t.join();
-  }
-  {
-    m.lock();
-    boost::thread t(f2);
-    boost::this_thread::sleep_for(ms(300));
-    m.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/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// unique_lock(mutex_type& m, try_to_lock_t);
-
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-#if defined BOOST_THREAD_USES_CHRONO
-
-boost::mutex m;
-
-typedef boost::chrono::system_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f()
-{
-  time_point t0 = Clock::now();
-  {
-    boost::unique_lock<boost::mutex> lk(m, boost::try_to_lock);
-    BOOST_TEST(lk.owns_lock() == false);
-  }
-  {
-    boost::unique_lock<boost::mutex> lk(m, boost::try_to_lock);
-    BOOST_TEST(lk.owns_lock() == false);
-  }
-  {
-    boost::unique_lock<boost::mutex> lk(m, boost::try_to_lock);
-    BOOST_TEST(lk.owns_lock() == false);
-  }
-  while (true)
-  {
-    boost::unique_lock<boost::mutex> lk(m, boost::try_to_lock);
-    if (lk.owns_lock()) break;
-  }
-  time_point t1 = Clock::now();
-  //m.unlock();
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(50000000)+ms(1000)); // within 50ms
-}
-
-int main()
-{
-  m.lock();
-  boost::thread t(f);
-  boost::this_thread::sleep_for(ms(250));
-  m.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/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp
@@ -1,83 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// void lock();
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <iostream>
-
-#if defined BOOST_THREAD_USES_CHRONO
-
-boost::mutex m;
-
-typedef boost::chrono::system_clock Clock;
-typedef Clock::time_point time_point;
-typedef Clock::duration duration;
-typedef boost::chrono::milliseconds ms;
-typedef boost::chrono::nanoseconds ns;
-
-void f()
-{
-  boost::unique_lock < boost::mutex > lk(m, boost::defer_lock);
-  time_point t0 = Clock::now();
-  lk.lock();
-  time_point t1 = Clock::now();
-  BOOST_TEST(lk.owns_lock() == true);
-  ns d = t1 - t0 - ms(250);
-  // This test is spurious as it depends on the time the thread system switches the threads
-  BOOST_TEST(d < ns(2500000)+ms(1000)); // within 2.5ms
-  try
-  {
-    lk.lock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
-  }
-  lk.unlock();
-  lk.release();
-  try
-  {
-    lk.lock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-}
-
-int main()
-{
-  m.lock();
-  boost::thread t(f);
-  boost::this_thread::sleep_for(ms(250));
-  m.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/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp
@@ -1,85 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// template <class Rep, class Period>
-//   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
-
-#include <boost/thread/locks.hpp>
-//#include <boost/thread/mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-#if defined BOOST_THREAD_USES_CHRONO
-
-
-bool try_lock_for_called = false;
-
-typedef boost::chrono::milliseconds ms;
-
-struct mutex
-{
-  template <class Rep, class Period>
-  bool try_lock_for(const boost::chrono::duration<Rep, Period>& rel_time)
-  {
-    BOOST_TEST(rel_time == ms(5));
-    try_lock_for_called = !try_lock_for_called;
-    return try_lock_for_called;
-  }
-  void unlock()
-  {
-  }
-};
-
-mutex m;
-
-int main()
-{
-  boost::unique_lock<mutex> lk(m, boost::defer_lock);
-  BOOST_TEST(lk.try_lock_for(ms(5)) == true);
-  BOOST_TEST(try_lock_for_called == true);
-  BOOST_TEST(lk.owns_lock() == true);
-  try
-  {
-    lk.try_lock_for(ms(5));
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
-  }
-  lk.unlock();
-  BOOST_TEST(lk.try_lock_for(ms(5)) == false);
-  BOOST_TEST(try_lock_for_called == false);
-  BOOST_TEST(lk.owns_lock() == false);
-  lk.release();
-  try
-  {
-    lk.try_lock_for(ms(5));
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-
-  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/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp
@@ -1,73 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// template <class Rep, class Period>
-//   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
-
-#include <boost/thread/locks.hpp>
-//#include <boost/thread/mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-bool try_lock_called = false;
-
-struct mutex
-{
-  bool try_lock()
-  {
-    try_lock_called = !try_lock_called;
-    return try_lock_called;
-  }
-  void unlock()
-  {
-  }
-};
-
-mutex m;
-
-int main()
-{
-  boost::unique_lock<mutex> lk(m, boost::defer_lock);
-  BOOST_TEST(lk.try_lock() == true);
-  BOOST_TEST(try_lock_called == true);
-  BOOST_TEST(lk.owns_lock() == true);
-  try
-  {
-    lk.try_lock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
-  }
-  lk.unlock();
-  BOOST_TEST(lk.try_lock() == false);
-  BOOST_TEST(try_lock_called == false);
-  BOOST_TEST(lk.owns_lock() == false);
-  lk.release();
-  try
-  {
-    lk.try_lock();
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-
-  return boost::report_errors();
-}
--- a/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp
+++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp
@@ -1,84 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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 unique_lock;
-
-// template <class Clock, class Duration>
-//   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
-
-#include <boost/thread/locks.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-#if defined BOOST_THREAD_USES_CHRONO
-
-
-bool try_lock_until_called = false;
-
-struct mutex
-{
-  template <class Clock, class Duration>
-  bool try_lock_until(const boost::chrono::time_point<Clock, Duration>& abs_time)
-  {
-    typedef boost::chrono::milliseconds ms;
-    BOOST_TEST(Clock::now() - abs_time < ms(5));
-    try_lock_until_called = !try_lock_until_called;
-    return try_lock_until_called;
-  }
-  void unlock()
-  {
-  }
-};
-
-mutex m;
-
-int main()
-{
-  typedef boost::chrono::steady_clock Clock;
-  boost::unique_lock<mutex> lk(m, boost::defer_lock);
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == true);
-  BOOST_TEST(try_lock_until_called == true);
-  BOOST_TEST(lk.owns_lock() == true);
-  try
-  {
-    lk.try_lock_until(Clock::now());
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
-  }
-  lk.unlock();
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == false);
-  BOOST_TEST(try_lock_until_called == false);
-  BOOST_TEST(lk.owns_lock() == false);
-  lk.release();
-  try
-  {
-    lk.try_lock_until(Clock::now());
-    BOOST_TEST(false);
-  }
-  catch (boost::system::system_error& e)
-  {
-    BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
-  }
-  return boost::report_errors();
-}
-
-#else
-#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
-#endif
-
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Beman Dawes	ee70b04fca	Release 1.49.0 beta 1 [SVN r76721]	2012-01-27 18:03:17 +00:00
Vicente J. Botet Escriba	09362f0eac	Thread: merge from trunk to fix #6141 , #5594 , #5040 and #5502 . [SVN r76346]	2012-01-07 20:52:57 +00:00
Vicente J. Botet Escriba	32b3f3f569	Thread: Fix typo on auto_ptr [SVN r76345]	2012-01-07 20:15:14 +00:00
Vicente J. Botet Escriba	8affa33718	Thread 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. [SVN r76291]	2012-01-03 17:31:50 +00:00
Anthony Williams	b991c9a8a0	Merged thread changes from trunk [SVN r72431]	2011-06-06 08:28:31 +00:00
Marshall Clow	ab665c8c56	Merge fixes to release; Fixes #1988 [SVN r71676]	2011-05-02 20:56:53 +00:00
Anthony Williams	7ec9804540	Merged Boost.Thread changes from trunk [SVN r70382]	2011-03-21 22:59:40 +00:00
Hartmut Kaiser	7c9116af2e	Spirit: merge from trunk [SVN r68078]	2011-01-13 02:11:19 +00:00
Anthony Williams	70584af9c0	Merged fix for issue #4736 from trunk [SVN r66588]	2010-11-15 10:13:12 +00:00
Anthony Williams	381554f8bc	Merged fix for issue #4736 from trunk [SVN r66482]	2010-11-10 11:24:52 +00:00
Anthony Williams	4dc1cb1ba1	Merged Boost.Thread from trunk [SVN r66259]	2010-10-29 23:27:00 +00:00
Vladimir Prus	506019dd62	Remove debug print [SVN r66171]	2010-10-25 07:52:02 +00:00
Vladimir Prus	e30be60bc4	Merge r64010, wherein jam has been moved. [SVN r65233]	2010-09-04 11:02:21 +00:00
Andrey Semashev	7bfafec128	Fixed compilation with MSVC and, probably, other compilers. [SVN r64999]	2010-08-25 16:41:08 +00:00
Anthony Williams	e12d2bc486	Marged changes to Boost.Thread from trunk [SVN r63915]	2010-07-12 07:47:39 +00:00
Anthony Williams	a37d2a1364	Merged boost.thread changes over from trunk [SVN r63789]	2010-07-09 19:13:09 +00:00
Daniel James	cc662c102c	Merge documentation fixes. * Use `doc/src/.css` instead of `doc/html/.css`. * Remove wiki and people directories. * Some documentation fixes. * Left out `minimal.css` changes and boostbook changes because of clashes. [SVN r63347]	2010-06-26 12:30:09 +00:00
Anthony Williams	65d2898ff0	Merged changes to boost.thread over from trunk [SVN r60991]	2010-04-01 15:04:15 +00:00
Anthony Williams	9087fd904d	Merged documentation changes to boost.thread (re at_thread_exit) from trunk [SVN r57381]	2009-11-04 21:48:18 +00:00
Anthony Williams	66ac6942b6	Merged boost.thread changes from trunk [SVN r57243]	2009-10-30 09:50:13 +00:00
Anthony Williams	20980fe54d	Merged thread changes from trunk [SVN r56992]	2009-10-19 09:18:13 +00:00
Troy D. Straszheim	fb54acfe69	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Troy D. Straszheim	0e69edd066	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
John Maddock	9255a035f4	Merge PDF build changes from Trunk. [SVN r51417]	2009-02-23 18:39:32 +00:00
Troy D. Straszheim	fbdc23f482	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Anthony Williams	8ab0d5acdd	Merged change from trunk removing catch(...) clauses [SVN r50524]	2009-01-09 11:06:53 +00:00
Daniel James	5af323102a	Merge [46445] - add line ending properties. Ref #2441 . [SVN r49577]	2008-11-03 22:29:39 +00:00
Anthony Williams	0997fad8ec	Merged Boost.Thread changes from trunk [SVN r49324]	2008-10-13 20:30:13 +00:00
Anthony Williams	8749696538	Merged Thread doc changes from trunk [SVN r48038]	2008-08-08 20:38:50 +00:00
Anthony Williams	9beea23f63	Merged thread doc changes from trunk [SVN r47827]	2008-07-26 08:39:51 +00:00
Anthony Williams	2978d43a5d	Merged thread doc changes from trunk [SVN r47701]	2008-07-23 09:37:02 +00:00
Anthony Williams	a264766584	Merged changes over from trunk [SVN r47700]	2008-07-23 09:35:40 +00:00
Anthony Williams	f03a9bfcf3	Merged thread changes from trunk [SVN r47211]	2008-07-08 07:44:55 +00:00
Anthony Williams	60fdcddcb5	Merge of new boost.thread code along with required changes from boost.bind [SVN r46474]	2008-06-18 13:01:08 +00:00
Anthony Williams	525d190f91	removed declaration of undefined type exclusive_lock [SVN r43850]	2008-03-25 07:59:58 +00:00
Anthony Williams	1e0154335b	Imported revision #43730 from trunk to eliminate some warnings [SVN r43743]	2008-03-21 15:04:10 +00:00
Anthony Williams	413c29a5e4	New documentation for thread library imported from trunk revision 43671 [SVN r43674]	2008-03-17 13:59:17 +00:00
Anthony Williams	30bb6143c1	Test and fix for bug #1693 to ensure thread_specific_ptr::release works as desired imported from trunk changeset 43666 [SVN r43673]	2008-03-17 13:46:19 +00:00
Anthony Williams	991ac727c6	Imported changeset 43461 to fix issue #1665 [SVN r43520]	2008-03-05 20:47:56 +00:00
Daniel James	569a78649f	Merged revisions 43211,43214-43219,43222-43225,43227-43238,43242,43244-43245,43249-43250,43257-43259,43261,43263,43265,43267-43268,43270-43271,43273,43275-43279,43284-43289,43291,43295,43297-43298,43304-43305,43307,43313,43315,43324,43326-43327,43331,43333,43339-43343,43345,43348,43350,43352-43353,43355-43356,43358,43360,43366-43367,43369-43370,43372-43376,43378-43389,43394,43396-43398,43400-43401,43403-43404,43406-43408,43413-43415,43417-43418,43420,43422-43423 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r43417 \| danieljames \| 2008-02-26 22:04:55 +0000 (Tue, 26 Feb 2008) \| 2 lines Fix a link to Boost.Bimap. ........ r43418 \| danieljames \| 2008-02-26 22:07:25 +0000 (Tue, 26 Feb 2008) \| 2 lines Change another link that's no longer in the repository to link to the website. ........ r43422 \| danieljames \| 2008-02-27 18:51:14 +0000 (Wed, 27 Feb 2008) \| 1 line Fix broken copyright urls. Fixes #1573. ........ r43423 \| danieljames \| 2008-02-27 19:22:01 +0000 (Wed, 27 Feb 2008) \| 1 line Fix incorrect links to copyright of the form 'http:#www.boost.org ........ [SVN r43425]	2008-02-27 20:00:24 +00:00
Anthony Williams	7caec1ec33	Fix for ticket #1547 --- Change use of NULL to 0 [SVN r43268]	2008-02-15 17:56:13 +00:00
Anthony Williams	7fd3fb48b1	Pulling changeset 43094 over from trunk [SVN r43227]	2008-02-12 20:49:56 +00:00
Anthony Williams	a32a3b37db	Merged latest changes to boost.thread over from trunk [SVN r42230]	2007-12-21 11:51:05 +00:00
Beman Dawes	88f6076f3c	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41370]	2007-11-25 18:38:02 +00:00
Beman Dawes	b4d12e08dd	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41369]	2007-11-25 18:07:19 +00:00
Beman Dawes	1c0f470032	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
nobody	92b8789532	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Thomas Witt	8f61694057	Fix #1039 . [SVN r37948]	2007-06-08 18:48:50 +00:00
Thomas Witt	67f7de5305	Fix #996 . [SVN r37815]	2007-05-29 17:12:59 +00:00
Anthony Williams	6faecefb73	Fix for ticket #906 [SVN r37740]	2007-05-22 15:38:58 +00:00
Anthony Williams	68c5bd44e8	undone accidental commit [SVN r37647]	2007-05-09 07:04:46 +00:00
Anthony Williams	3656277053	Removed read_write_mutex source files and header [SVN r37646]	2007-05-09 07:02:13 +00:00
Thomas Witt	19846ff356	Fix Xml error. This change is already in HEAD. [SVN r37499]	2007-04-24 16:11:17 +00:00
Roland Schwarz	db2aaa04fd	Merged from HEAD. [SVN r36923]	2007-02-11 13:55:21 +00:00
Roland Schwarz	b48f9aa609	Merged patch from trunk. [SVN r36921]	2007-02-11 13:14:44 +00:00
Anthony Williams	7915ab1ec6	Fixed typos and improved phrasing [SVN r36751]	2007-01-18 17:33:50 +00:00
Roland Schwarz	f0faf88d66	Updated the build instructions and acknowledgements. [SVN r36706]	2007-01-12 16:48:02 +00:00
Roland Schwarz	7dd7537f5f	renamed back to .v2 since build process is broken otherwise. [SVN r36641]	2007-01-07 14:53:25 +00:00
Roland Schwarz	f51680e8d9	Renamed Jamfile. [SVN r36640]	2007-01-07 14:08:02 +00:00
Roland Schwarz	a6bc072c6d	removing obsolete files [SVN r36639]	2007-01-07 14:05:30 +00:00
Roland Schwarz	85f2508157	Updating build instructions. [SVN r36638]	2007-01-07 12:33:42 +00:00
Roland Schwarz	ebb6c8d637	Corrected a typo; more prominent note of unavailability of RW-Mutex. [SVN r36565]	2007-01-02 21:44:39 +00:00
Roland Schwarz	ddc83e270c	Corrected a typo, and reactivated links to read_write mutex. [SVN r36560]	2007-01-01 16:45:52 +00:00
Roland Schwarz	0173148a2e	Recovered file, since it is linked to rest of doc. [SVN r36559]	2007-01-01 14:10:28 +00:00
Roland Schwarz	69a4ec6c00	QNX debuging [SVN r36489]	2006-12-22 13:40:38 +00:00
Roland Schwarz	2d52219af2	Merged from HEAD [SVN r36488]	2006-12-22 10:38:23 +00:00
Roland Schwarz	1f87a9e4c0	Temporary test code for QNX debugging. [SVN r36430]	2006-12-16 16:17:55 +00:00
Roland Schwarz	ba8afde42b	Additional asserions in an attempt to find the errors on QNX. [SVN r36395]	2006-12-14 21:44:20 +00:00
Roland Schwarz	93f677cba6	Changed back to CHECK since WARNING not showing up in regression tables. [SVN r36387]	2006-12-14 17:51:25 +00:00
Roland Schwarz	dfd865d67d	Fixed missing tss_null file. [SVN r36332]	2006-12-11 19:51:14 +00:00
Vladimir Prus	96a04402db	Merge from HEAD. Allow building of shared versions of some Boost.Test libraries. Adjust tests to use always use static linking to Boost.Test, since linking to the shared version requires test changes. Patch from Juergen Hunold. [SVN r35990]	2006-11-10 19:59:52 +00:00
Anthony Williams	78e644c7c1	removed docs for read_write_mutex [SVN r35976]	2006-11-10 15:51:13 +00:00
Rene Rivera	89cc7fc34e	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
Roland Schwarz	974754598e	Removed recursive_mutex from library builds and regression testing for RC_1_34_0 branch. [SVN r35818]	2006-11-03 04:39:17 +00:00
Roland Schwarz	87acbb406d	Forced read_write_mutex unusable for RC_1_34_0 branch. [SVN r35817]	2006-11-03 04:37:45 +00:00
Roland Schwarz	597517157c	Updated documentation for the RC_1_34_0 branch to reflect current state of read_write_mutex. [SVN r35816]	2006-11-03 04:05:55 +00:00
Roland Schwarz	a0b816be8c	Get rid of dll import warnings for noncopyable classes [SVN r35797]	2006-10-30 19:35:40 +00:00
Roland Schwarz	4a056924d2	Added a warning about usage of read_write_mutex. [SVN r35675]	2006-10-20 17:26:18 +00:00
Roland Schwarz	d5a81f990c	Inified spelling of thread library in documentation. (singular) Added RC_1_34_0 release notes. [SVN r35619]	2006-10-15 14:52:54 +00:00
Markus Schöpflin	da8c92f057	Reverted last checkin. Works when patching the compiler. [SVN r35495]	2006-10-05 08:08:40 +00:00
Roland Schwarz	866b33c808	Untabified file [SVN r35458]	2006-10-03 18:23:06 +00:00
Roland Schwarz	182daf0b17	Disabled certain borland warnings [SVN r35449]	2006-10-02 21:22:49 +00:00
Roland Schwarz	2552febc2a	Made non-availability of automatic TSS cleanup for native Windows threads a warning instead of an error. [SVN r35448]	2006-10-02 21:19:55 +00:00
Roland Schwarz	eb9db9b683	Added changes for MSVC 7.0 [SVN r35445]	2006-10-02 18:17:26 +00:00
Roland Schwarz	11dbdfca4d	added assertions around gettimeofday and clock_gettime [SVN r35439]	2006-10-02 09:45:28 +00:00
Markus Schöpflin	f49de9ec10	Disable threading tests on Tru64/GCC-4.1.1. [SVN r35438]	2006-10-02 09:07:47 +00:00
Roland Schwarz	3a7e569a65	Test if this turns regressions green on win x64 platforms [SVN r35437]	2006-10-02 07:49:04 +00:00
Roland Schwarz	c376c1a62a	Removed the "intentional memory leak" of the TSS implementation. [SVN r35434]	2006-10-01 12:57:18 +00:00
Roland Schwarz	fbbc52063a	avoid complaints of boostinspect about unnamed namespace usage [SVN r35412]	2006-09-29 07:49:51 +00:00
Roland Schwarz	78b4fe3d07	avoid complaints of boostinspect about unnamed namespace usage [SVN r35411]	2006-09-29 07:36:49 +00:00
Roland Schwarz	b8c8b250b1	Removed try catch(...) from thread proxy [SVN r35328]	2006-09-26 03:05:06 +00:00
Roland Schwarz	b26d01c8d7	Fixed on of the memory leaks related to TSS [SVN r35324]	2006-09-25 23:53:10 +00:00
Hartmut Kaiser	4dbd8a66af	Changed Boost.Thread to use the Boost license. [SVN r35115]	2006-09-14 23:02:29 +00:00
Hartmut Kaiser	cb4d739fd1	Changed Boost.Thread to use the Boost license. [SVN r35112]	2006-09-14 21:51:01 +00:00
Anthony Williams	11f913e8fb	added BSL for files with authors in blanket_permissions.txt [SVN r35090]	2006-09-13 14:11:49 +00:00
Anthony Williams	0b6054a919	added boostinspect:nolicense to files with old license from William Kempf [SVN r35087]	2006-09-13 08:54:53 +00:00
Anthony Williams	e7620a1050	added boostinspect:nolicense to files with old license from William Kempf [SVN r35086]	2006-09-13 08:33:30 +00:00
Nicola Musatti	811a03f281	Updated Borland workaround [SVN r33942]	2006-05-05 21:13:45 +00:00
Anthony Williams	2528bd0b8f	Added patch from http://lists.boost.org/Archives/boost/2005/05/86395.php to fix bug https://sourceforge.net/tracker/index.php?func=detail&aid=1424965&group_id=7586&atid=107586 [SVN r33802]	2006-04-25 10:06:38 +00:00
Vladimir Prus	ed587be470	Merge from trunk [SVN r33597]	2006-04-07 14:01:36 +00:00
nobody	55b48874a4	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00