Branch at revision 46530

[SVN r46531]
Correctly remove the reference type when copying the thread function into the thread data area so we don't end up with a dangling reference
2026-02-04 09:52:14 +00:00 · 2008-06-19 18:57:10 +00:00 · 2008-06-10 15:29:35 +00:00 · 2008-06-09 14:00:03 +00:00 · 2008-06-07 20:54:19 +00:00 · 2008-06-05 12:25:58 +00:00
45 changed files with 529 additions and 1940 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,22 +0,0 @@
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    thread.hpp
-    thread
-)
-
-# Add a library target to the build system
-boost_library_project(
-  thread
-  SRCDIRS  src 
-  TESTDIRS  test
-  HEADERS ${lib_headers}
-  #  DOCDIRS 
-  #  DESCRIPTION 
-  MODULARIZED 
-  #  AUTHORS 
-  #  MAINTAINERS 
-)
-
-
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -31,6 +31,25 @@ boostbook standalone
        # Use the main Boost stylesheet:
        <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
        
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        #<xsl:param>fop1.extensions=1
+        # Or enable this if you're using XEP:
+        <xsl:param>xep.extensions=1
+        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
    ;

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

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

 A barrier is a simple concept. Also known as a ['rendezvous], it is a synchronization point between multiple threads. The barrier is
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -1,27 +1,4 @@
-[/
-  (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 Changes since boost 1.35]
-
-The 1.36.0 release of Boost includes a few new features in the thread library:
-
-* New generic __lock_multiple_ref__ and __try_lock_multiple_ref__ functions for locking multiple mutexes at once.
-
-* Rvalue reference support for move semantics where the compilers supports it.
-
-* A few bugs fixed and missing functions added (including the serious win32 condition variable bug).
-
-* `scoped_try_lock` types are now backwards-compatible with Boost 1.34.0 and previous releases.
-
-* Support for passing function arguments to the thread function by supplying additional arguments to the __thread__ constructor.
-
-* Backwards-compatibility overloads added for `timed_lock` and `timed_wait` functions to allow use of `xtime` for timeouts.
-
-[heading Changes since boost 1.34]
+[section:changes Changes since boost 1.34]

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

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

-* When using a __recursive_mutex__ with a call to [cond_any_wait_link `boost::condition_variable_any::wait()`], the mutex is only
-  unlocked one level, and not completely. This prior behaviour was not guaranteed and did not feature in the tests.
-
 [endsect]
--- a/doc/condition_variables.qbk
+++ b/doc/condition_variables.qbk
@@ -1,10 +1,3 @@
-[/
-  (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:condvar_ref Condition Variables]

 [heading Synopsis]
@@ -74,8 +67,6 @@ optimizations in some cases, based on the knowledge of the mutex type;

 [section:condition_variable Class `condition_variable`]

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

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

            template<typename predicate_type>
@@ -296,8 +284,6 @@ return true;

 [section:condition_variable_any Class `condition_variable_any`]

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

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

@@ -502,8 +485,6 @@ return true;

 [section:condition Typedef `condition`]

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

 The typedef `condition` is provided for backwards compatibility with previous boost releases.
--- a/doc/mutex_concepts.qbk
+++ b/doc/mutex_concepts.qbk
@@ -1,10 +1,3 @@
-[/
-  (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:mutex_concepts Mutex Concepts]

 A mutex object facilitates protection against data races and allows thread-safe synchronization of data between threads. A thread
@@ -312,8 +305,6 @@ without blocking.]]

 [section:lock_guard Class template `lock_guard`]

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

 [section:unique_lock Class template `unique_lock`]

-    #include <boost/thread/locks.hpp>
-
    template<typename Lockable>
    class unique_lock
    {
@@ -621,8 +610,6 @@ __owns_lock_ref__ returns `false`.]]

 [section:shared_lock Class template `shared_lock`]

-    #include <boost/thread/locks.hpp>
-
    template<typename Lockable>
    class shared_lock
    {
@@ -856,8 +843,6 @@ __owns_lock_shared_ref__ returns `false`.]]

 [section:upgrade_lock Class template `upgrade_lock`]

-    #include <boost/thread/locks.hpp>
-
    template<typename Lockable>
    class upgrade_lock
    {
@@ -905,8 +890,6 @@ state (including the destructor) must be called by the same thread that acquired

 [section:upgrade_to_unique_lock Class template `upgrade_to_unique_lock`]

-    #include <boost/thread/locks.hpp>
-
    template <class Lockable>
    class upgrade_to_unique_lock
    {
@@ -931,189 +914,4 @@ __lockable_concept_type__ is downgraded back to ['upgrade ownership].

 [endsect]

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

 [section:mutex Class `mutex`]

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

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

 [section:try_mutex Typedef `try_mutex`]

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

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

 [section:timed_mutex Class `timed_mutex`]

-    #include <boost/thread/mutex.hpp>
-
    class timed_mutex:
        boost::noncopyable
    {
@@ -84,7 +71,7 @@ __try_mutex__ is a `typedef` to __mutex__, provided for backwards compatibility
        native_handle_type native_handle();

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

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

 [section:recursive_mutex Class `recursive_mutex`]

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

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

 [section:recursive_try_mutex Typedef `recursive_try_mutex`]

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

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

 [section:recursive_timed_mutex Class `recursive_timed_mutex`]

-    #include <boost/thread/recursive_mutex.hpp>
-
    class recursive_timed_mutex:
        boost::noncopyable
    {
@@ -190,7 +171,7 @@ __recursive_try_mutex__ is a `typedef` to __recursive_mutex__, provided for back
        native_handle_type native_handle();
        
        typedef unique_lock<recursive_timed_mutex> scoped_lock;
-        typedef unspecified-type scoped_try_lock;
+        typedef scoped_lock scoped_try_lock;
        typedef scoped_lock scoped_timed_lock;
    };

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

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

 [section:once_flag Typedef `once_flag`]

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

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

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

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

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

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

--- a/doc/overview.qbk
+++ b/doc/overview.qbk
@@ -1,10 +1,3 @@
-[/
-  (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:overview Overview]

 __boost_thread__ enables the use of multiple threads of execution with shared data in portable C++ code. It provides classes and
@@ -19,12 +12,4 @@ closely follow the proposals presented to the C++ Standards Committee, in partic
 [@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]

-In order to use the classes and functions described here, you can
-either include the specific headers specified by the descriptions of
-each class or function, or include the master thread library header:
-
-    #include <boost/thread.hpp>
-
-which includes all the other headers in turn.
-
 [endsect]
--- a/doc/shared_mutex_ref.qbk
+++ b/doc/shared_mutex_ref.qbk
@@ -1,14 +1,5 @@
-[/
-  (C) Copyright 2007-8 Anthony Williams.
-  Distributed under the Boost Software License, Version 1.0.
-  (See accompanying file LICENSE_1_0.txt or copy at
-  http://www.boost.org/LICENSE_1_0.txt).
-]
-
 [section:shared_mutex Class `shared_mutex`]

-    #include <boost/thread/shared_mutex.hpp>
-
    class shared_mutex
    {
    public:
--- a/doc/thread.qbk
+++ b/doc/thread.qbk
@@ -1,10 +1,3 @@
-[/
-  (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.4]
    [authors [Williams, Anthony]]
@@ -38,12 +31,6 @@
 [template lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.lockable.lock [link_text]]]
 [def __lock_ref__ [lock_ref_link `lock()`]]

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

@@ -107,10 +94,8 @@
 [def __recursive_timed_mutex__ [link thread.synchronization.mutex_types.recursive_timed_mutex `boost::recursive_timed_mutex`]]
 [def __shared_mutex__ [link thread.synchronization.mutex_types.shared_mutex `boost::shared_mutex`]]

-[template unique_lock_link[link_text] [link thread.synchronization.locks.unique_lock [link_text]]]
-
 [def __lock_guard__ [link thread.synchronization.locks.lock_guard `boost::lock_guard`]]
-[def __unique_lock__ [unique_lock_link `boost::unique_lock`]]
+[def __unique_lock__ [link thread.synchronization.locks.unique_lock `boost::unique_lock`]]
 [def __shared_lock__ [link thread.synchronization.locks.shared_lock `boost::shared_lock`]]
 [def __upgrade_lock__ [link thread.synchronization.locks.upgrade_lock `boost::upgrade_lock`]]
 [def __upgrade_to_unique_lock__ [link thread.synchronization.locks.upgrade_to_unique_lock `boost::upgrade_to_unique_lock`]]
--- a/doc/thread_ref.qbk
+++ b/doc/thread_ref.qbk
@@ -1,10 +1,3 @@
-[/
-  (C) Copyright 2007-8 Anthony Williams.
-  Distributed under the Boost Software License, Version 1.0.
-  (See accompanying file LICENSE_1_0.txt or copy at
-  http://www.boost.org/LICENSE_1_0.txt).
-]
-
 [section:thread_management Thread Management]

 [heading Synopsis]
@@ -165,8 +158,6 @@ __thread_id__ yield a total order for every non-equal thread ID.

 [section:thread Class `thread`]

-    #include <boost/thread/thread.hpp>
-
    class thread
    {
    public:
@@ -176,9 +167,6 @@ __thread_id__ yield a total order for every non-equal thread ID.
        template <class F>
        explicit thread(F f);

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

@@ -255,30 +243,6 @@ not of type __thread_interrupted__, then `std::terminate()` will be called.]]

 [endsect]

-[section:multiple_argument_constructor Thread Constructor with arguments]
-
-    template <class F,class A1,class A2,...>
-    thread(F f,A1 a1,A2 a2,...);
-
-[variablelist
-
-[[Preconditions:] [`F` and each `A`n must by copyable or movable.]]
-
-[[Effects:] [As if [link
-thread.thread_management.thread.callable_constructor
-`thread(boost::bind(f,a1,a2,...))`. Consequently, `f` and each `a`n
-are copied into internal storage for access by the new thread.]]]
-
-[[Postconditions:] [`*this` refers to the newly created thread of execution.]]
-
-[[Throws:] [__thread_resource_error__ if an error occurs.]]
-
-[[Note:] [Currently up to nine additional arguments `a1` to `a9` can be specified in addition to the function `f`.]]
-
-]
-
-[endsect]
-
 [section:destructor Thread Destructor]

    ~thread();
@@ -509,8 +473,6 @@ value as `this->get_id()` prior to the call.]]

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

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

 [variablelist
@@ -524,8 +486,6 @@ value as `this->get_id()` prior to the call.]]

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

-    #include <boost/thread/thread.hpp>
-
    class thread::id
    {
    public:
@@ -674,8 +634,6 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

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

-    #include <boost/thread/thread.hpp>
-
    namespace this_thread
    {
        thread::id get_id();
@@ -693,8 +651,6 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

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

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

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

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

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

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

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

-    #include <boost/thread/thread.hpp>
-
    namespace this_thread
    {
        template<typename TimeDuration>
@@ -772,8 +722,6 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `

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

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

 [section:disable_interruption Class `disable_interruption`]

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

 [section:restore_interruption Class `restore_interruption`]

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

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

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

 [variablelist

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

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

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

 [section:threadgroup Class `thread_group`]

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

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

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

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

 [variablelist

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

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

 [section:system_time Typedef `system_time`]

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

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

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

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

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

 [heading Synopsis]
@@ -44,8 +37,6 @@ cleaned up, that value is added to the cleanup list. Cleanup finishes when there

 [section:thread_specific_ptr Class `thread_specific_ptr`]

-    #include <boost/thread/tss.hpp>
-
    template <typename T>
    class thread_specific_ptr
    {
--- a/include/boost/thread/detail/move.hpp
+++ b/include/boost/thread/detail/move.hpp
@@ -6,10 +6,8 @@
 #ifndef BOOST_THREAD_MOVE_HPP
 #define BOOST_THREAD_MOVE_HPP

-#ifndef BOOST_NO_SFINAE
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_convertible.hpp>
-#endif

 #include <boost/config/abi_prefix.hpp>

@@ -39,13 +37,11 @@ namespace boost
        };
    }

-#ifndef BOOST_NO_SFINAE
    template<typename T>
-    typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, T >::type move(T& t)
+    typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, detail::thread_move_t<T> >::type move(T& t)
    {
-        return T(detail::thread_move_t<T>(t));
+        return t;
    }
-#endif
    
    template<typename T>
    detail::thread_move_t<T> move(detail::thread_move_t<T> t)
--- a/include/boost/thread/detail/platform.hpp
+++ b/include/boost/thread/detail/platform.hpp
@@ -42,9 +42,9 @@
 #elif defined(__QNXNTO__)
 #  define BOOST_THREAD_QNXNTO
 #elif defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE)
-#       if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_THREAD_POSIX)
-#               define BOOST_THREAD_POSIX
-#       endif
+#	if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_THREAD_POSIX)
+#		define BOOST_THREAD_POSIX
+#	endif
 #endif

 // For every supported platform add a new entry into the dispatch table below.
--- a/include/boost/thread/detail/thread.hpp
+++ b/include/boost/thread/detail/thread.hpp
@@ -172,14 +172,6 @@ namespace boost
            return static_cast<thread&&>(*this);
        }
        
-#else
-#ifdef BOOST_NO_SFINAE
-        template <class F>
-        explicit thread(F f):
-            thread_info(make_thread_info(f))
-        {
-            start_thread();
-        }
 #else
        template <class F>
        explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
@@ -187,10 +179,9 @@ namespace boost
        {
            start_thread();
        }
-#endif
        
        template <class F>
-        explicit thread(detail::thread_move_t<F> f):
+        thread(detail::thread_move_t<F> f):
            thread_info(make_thread_info(f))
        {
            start_thread();
@@ -339,9 +330,9 @@ namespace boost
        return t;
    }
 #else
-    inline thread move(detail::thread_move_t<thread> t)
+    inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
    {
-        return thread(t);
+        return t;
    }
 #endif

--- a/include/boost/thread/locks.hpp
+++ b/include/boost/thread/locks.hpp
@@ -10,21 +10,12 @@
 #include <algorithm>
 #include <iterator>
 #include <boost/thread/thread_time.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/utility/enable_if.hpp>

 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
-    struct xtime;
-
-#if defined(BOOST_NO_SFINAE) ||                           \
-    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) || \
-    BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-#define BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
-#endif
-
-#ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
    namespace detail
    {
        template<typename T>
@@ -86,13 +77,7 @@ namespace boost
                              detail::has_member_try_lock<T>::value);
        
    };
-#else
-    template<typename T>
-    struct is_mutex_type
-    {
-        BOOST_STATIC_CONSTANT(bool, value = false);
-    };
-#endif    
+    

    struct defer_lock_t
    {};
@@ -111,74 +96,6 @@ namespace boost
    template<typename Mutex>
    class upgrade_lock;

-    template<typename Mutex>
-    class unique_lock;
-
-    namespace detail
-    {
-        template<typename Mutex>
-        class try_lock_wrapper;
-    }
-    
-#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
-    template<typename T>
-    struct is_mutex_type<unique_lock<T> >
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-    template<typename T>
-    struct is_mutex_type<shared_lock<T> >
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-    template<typename T>
-    struct is_mutex_type<upgrade_lock<T> >
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    
-    template<typename T>
-    struct is_mutex_type<detail::try_lock_wrapper<T> >
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-    class mutex;
-    class timed_mutex;
-    class recursive_mutex;
-    class recursive_timed_mutex;
-    class shared_mutex;
-    
-    template<>
-    struct is_mutex_type<mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    template<>
-    struct is_mutex_type<timed_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    template<>
-    struct is_mutex_type<recursive_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    template<>
-    struct is_mutex_type<recursive_timed_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    template<>
-    struct is_mutex_type<shared_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-#endif
-
    template<typename Mutex>
    class lock_guard
    {
@@ -209,10 +126,8 @@ namespace boost
    private:
        Mutex* m;
        bool is_locked;
-        unique_lock(unique_lock&);
-        explicit unique_lock(upgrade_lock<Mutex>&);
+        explicit unique_lock(unique_lock&);
        unique_lock& operator=(unique_lock&);
-        unique_lock& operator=(upgrade_lock<Mutex>& other);
    public:
        unique_lock():
            m(0),is_locked(false)
@@ -234,51 +149,11 @@ namespace boost
        {
            try_lock();
        }
-        template<typename TimeDuration>
-        unique_lock(Mutex& m_,TimeDuration const& target_time):
-            m(&m_),is_locked(false)
-        {
-            timed_lock(target_time);
-        }
        unique_lock(Mutex& m_,system_time const& target_time):
            m(&m_),is_locked(false)
        {
            timed_lock(target_time);
        }
-#ifdef BOOST_HAS_RVALUE_REFS
-        unique_lock(unique_lock&& other):
-            m(other.m),is_locked(other.is_locked)
-        {
-            other.is_locked=false;
-            other.m=0;
-        }
-        explicit unique_lock(upgrade_lock<Mutex>&& other);
-
-        unique_lock<Mutex>&& move()
-        {
-            return static_cast<unique_lock<Mutex>&&>(*this);
-        }
-
-
-        unique_lock& operator=(unique_lock<Mutex>&& other)
-        {
-            unique_lock temp(other);
-            swap(temp);
-            return *this;
-        }
-
-        unique_lock& operator=(upgrade_lock<Mutex>&& other)
-        {
-            unique_lock temp(other);
-            swap(temp);
-            return *this;
-        }
-        void swap(unique_lock&& other)
-        {
-            std::swap(m,other.m);
-            std::swap(is_locked,other.is_locked);
-        }
-#else
        unique_lock(detail::thread_move_t<unique_lock<Mutex> > other):
            m(other->m),is_locked(other->is_locked)
        {
@@ -310,6 +185,7 @@ namespace boost
            swap(temp);
            return *this;
        }
+
        void swap(unique_lock& other)
        {
            std::swap(m,other.m);
@@ -320,7 +196,6 @@ namespace boost
            std::swap(m,other->m);
            std::swap(is_locked,other->is_locked);
        }
-#endif
        
        ~unique_lock()
        {
@@ -359,11 +234,6 @@ namespace boost
            is_locked=m->timed_lock(absolute_time);
            return is_locked;
        }
-        bool timed_lock(::boost::xtime const& absolute_time)
-        {
-            is_locked=m->timed_lock(absolute_time);
-            return is_locked;
-        }
        void unlock()
        {
            if(!owns_lock())
@@ -405,27 +275,11 @@ namespace boost
        friend class upgrade_lock<Mutex>;
    };

-#ifdef BOOST_HAS_RVALUE_REFS
-    template<typename Mutex>
-    void swap(unique_lock<Mutex>&& lhs,unique_lock<Mutex>&& rhs)
-    {
-        lhs.swap(rhs);
-    }
-#else
    template<typename Mutex>
    void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs)
    {
        lhs.swap(rhs);
    }
-#endif
-
-#ifdef BOOST_HAS_RVALUE_REFS
-    template<typename Mutex>
-    inline unique_lock<Mutex>&& move(unique_lock<Mutex>&& ul)
-    {
-        return ul;
-    }
-#endif

    template<typename Mutex>
    class shared_lock
@@ -524,29 +378,11 @@ namespace boost
            return *this;
        }

-#ifdef BOOST_HAS_RVALUE_REFS
-        void swap(shared_lock&& other)
-        {
-            std::swap(m,other.m);
-            std::swap(is_locked,other.is_locked);
-        }
-#else
        void swap(shared_lock& other)
        {
            std::swap(m,other.m);
            std::swap(is_locked,other.is_locked);
        }
-        void swap(boost::detail::thread_move_t<shared_lock<Mutex> > other)
-        {
-            std::swap(m,other->m);
-            std::swap(is_locked,other->is_locked);
-        }
-#endif
-
-        Mutex* mutex() const
-        {
-            return m;
-        }
        
        ~shared_lock()
        {
@@ -582,16 +418,6 @@ namespace boost
            is_locked=m->timed_lock_shared(target_time);
            return is_locked;
        }
-        template<typename Duration>
-        bool timed_lock(Duration const& target_time)
-        {
-            if(owns_lock())
-            {
-                throw boost::lock_error();
-            }
-            is_locked=m->timed_lock_shared(target_time);
-            return is_locked;
-        }
        void unlock()
        {
            if(!owns_lock())
@@ -602,7 +428,7 @@ namespace boost
            is_locked=false;
        }
            
-        typedef void (shared_lock<Mutex>::*bool_type)();
+        typedef void (shared_lock::*bool_type)();
        operator bool_type() const
        {
            return is_locked?&shared_lock::lock:0;
@@ -618,20 +444,6 @@ namespace boost

    };

-#ifdef BOOST_HAS_RVALUE_REFS
-    template<typename Mutex>
-    void swap(shared_lock<Mutex>&& lhs,shared_lock<Mutex>&& rhs)
-    {
-        lhs.swap(rhs);
-    }
-#else
-    template<typename Mutex>
-    void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs)
-    {
-        lhs.swap(rhs);
-    }
-#endif
-
    template<typename Mutex>
    class upgrade_lock
    {
@@ -764,18 +576,6 @@ namespace boost
    };


-#ifdef BOOST_HAS_RVALUE_REFS
-    template<typename Mutex>
-    unique_lock<Mutex>::unique_lock(upgrade_lock<Mutex>&& other):
-        m(other.m),is_locked(other.is_locked)
-    {
-        other.is_locked=false;
-        if(is_locked)
-        {
-            m.unlock_upgrade_and_lock();
-        }
-    }
-#else
    template<typename Mutex>
    unique_lock<Mutex>::unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
        m(other->m),is_locked(other->is_locked)
@@ -786,7 +586,7 @@ namespace boost
            m->unlock_upgrade_and_lock();
        }
    }
-#endif
+
    template <class Mutex>
    class upgrade_to_unique_lock
    {
@@ -885,12 +685,6 @@ namespace boost
                return *this;
            }

-#ifdef BOOST_HAS_RVALUE_REFS
-            void swap(try_lock_wrapper&& other)
-            {
-                base::swap(other);
-            }
-#else
            void swap(try_lock_wrapper& other)
            {
                base::swap(other);
@@ -899,7 +693,6 @@ namespace boost
            {
                base::swap(*other);
            }
-#endif

            void lock()
            {
@@ -933,23 +726,15 @@ namespace boost
            typedef typename base::bool_type bool_type;
            operator bool_type() const
            {
-                return base::operator bool_type();
+                return static_cast<base const&>(*this);
            }
        };

-#ifdef BOOST_HAS_RVALUE_REFS
-        template<typename Mutex>
-        void swap(try_lock_wrapper<Mutex>&& lhs,try_lock_wrapper<Mutex>&& rhs)
-        {
-            lhs.swap(rhs);
-        }
-#else
        template<typename Mutex>
        void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs)
        {
            lhs.swap(rhs);
        }
-#endif
        
        template<typename MutexType1,typename MutexType2>
        unsigned try_lock_internal(MutexType1& m1,MutexType2& m2)
@@ -1074,63 +859,28 @@ namespace boost
        }
    }

-    namespace detail
+    template<typename MutexType1,typename MutexType2>
+    typename enable_if<is_mutex_type<MutexType1>, void>::type lock(MutexType1& m1,MutexType2& m2)
    {
-        template<bool x>
-        struct is_mutex_type_wrapper
-        {};
-        
-        template<typename MutexType1,typename MutexType2>
-        void lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>)
+        unsigned const lock_count=2;
+        unsigned lock_first=0;
+        while(true)
        {
-            unsigned const lock_count=2;
-            unsigned lock_first=0;
-            while(true)
+            switch(lock_first)
            {
-                switch(lock_first)
-                {
-                case 0:
-                    lock_first=detail::lock_helper(m1,m2);
-                    if(!lock_first)
-                        return;
-                    break;
-                case 1:
-                    lock_first=detail::lock_helper(m2,m1);
-                    if(!lock_first)
-                        return;
-                    lock_first=(lock_first+1)%lock_count;
-                    break;
-                }
+            case 0:
+                lock_first=detail::lock_helper(m1,m2);
+                if(!lock_first)
+                    return;
+                break;
+            case 1:
+                lock_first=detail::lock_helper(m2,m1);
+                if(!lock_first)
+                    return;
+                lock_first=(lock_first+1)%lock_count;
+                break;
            }
        }
-
-        template<typename Iterator>
-        void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>);
-    }
-    
-
-    template<typename MutexType1,typename MutexType2>
-    void lock(MutexType1& m1,MutexType2& m2)
-    {
-        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    void lock(const MutexType1& m1,MutexType2& m2)
-    {
-        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    void lock(MutexType1& m1,const MutexType2& m2)
-    {
-        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    void lock(const MutexType1& m1,const MutexType2& m2)
-    {
-        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
    }

    template<typename MutexType1,typename MutexType2,typename MutexType3>
@@ -1245,52 +995,10 @@ namespace boost
        }
    }

-    namespace detail
-    {
-        template<typename Mutex,bool x=is_mutex_type<Mutex>::value>
-        struct try_lock_impl_return
-        {
-            typedef int type;
-        };
-        
-        template<typename Iterator>
-        struct try_lock_impl_return<Iterator,false>
-        {
-            typedef Iterator type;
-        };
-
-        template<typename MutexType1,typename MutexType2>
-        int try_lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>)
-        {
-            return ((int)detail::try_lock_internal(m1,m2))-1;
-        }
-
-        template<typename Iterator>
-        Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>);
-    }
-    
    template<typename MutexType1,typename MutexType2>
-    typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,MutexType2& m2)
+    typename enable_if<is_mutex_type<MutexType1>, int>::type try_lock(MutexType1& m1,MutexType2& m2)
    {
-        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,MutexType2& m2)
-    {
-        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,const MutexType2& m2)
-    {
-        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,const MutexType2& m2)
-    {
-        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
+        return ((int)detail::try_lock_internal(m1,m2))-1;
    }

    template<typename MutexType1,typename MutexType2,typename MutexType3>
@@ -1312,6 +1020,9 @@ namespace boost
    }
    

+    template<typename Iterator>
+    typename disable_if<is_mutex_type<Iterator>, void>::type lock(Iterator begin,Iterator end);
+    
    namespace detail
    {
        template<typename Iterator>
@@ -1339,59 +1050,70 @@ namespace boost
                }
            }
        };
-
-        template<typename Iterator>
-        Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
-
-        {
-            if(begin==end)
-            {
-                return end;
-            }
-            typedef typename std::iterator_traits<Iterator>::value_type lock_type;
-            unique_lock<lock_type> guard(*begin,try_to_lock);
-            
-            if(!guard.owns_lock())
-            {
-                return begin;
-            }
-            Iterator const failed=try_lock(++begin,end);
-            if(failed==end)
-            {
-                guard.release();
-            }
-            
-            return failed;
-        }
    }
-    

-    namespace detail
+    template<typename Iterator>
+    typename disable_if<is_mutex_type<Iterator>, Iterator>::type try_lock(Iterator begin,Iterator end)
    {
-        template<typename Iterator>
-        void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
+        if(begin==end)
        {
-            typedef typename std::iterator_traits<Iterator>::value_type lock_type;
+            return end;
+        }
+        typedef typename std::iterator_traits<Iterator>::value_type lock_type;
+        unique_lock<lock_type> guard(*begin,try_to_lock);
        
-            if(begin==end)
-            {
-                return;
-            }
-            bool start_with_begin=true;
-            Iterator second=begin;
-            ++second;
-            Iterator next=second;
+        if(!guard.owns_lock())
+        {
+            return begin;
+        }
+        Iterator const failed=try_lock(++begin,end);
+        if(failed==end)
+        {
+            guard.release();
+        }
        
-            for(;;)
+        return failed;
+    }
+
+    template<typename Iterator>
+    typename disable_if<is_mutex_type<Iterator>, void>::type lock(Iterator begin,Iterator end)
+    {
+        typedef typename std::iterator_traits<Iterator>::value_type lock_type;
+        
+        if(begin==end)
+        {
+            return;
+        }
+        bool start_with_begin=true;
+        Iterator second=begin;
+        ++second;
+        Iterator next=second;
+        
+        for(;;)
+        {
+            unique_lock<lock_type> begin_lock(*begin,defer_lock);
+            if(start_with_begin)
            {
-                unique_lock<lock_type> begin_lock(*begin,defer_lock);
-                if(start_with_begin)
+                begin_lock.lock();
+                Iterator const failed_lock=try_lock(next,end);
+                if(failed_lock==end)
                {
-                    begin_lock.lock();
-                    Iterator const failed_lock=try_lock(next,end);
-                    if(failed_lock==end)
+                    begin_lock.release();
+                    return;
+                }
+                start_with_begin=false;
+                next=failed_lock;
+            }
+            else
+            {
+                detail::range_lock_guard<Iterator> guard(next,end);
+                if(begin_lock.try_lock())
+                {
+                    Iterator const failed_lock=try_lock(second,next);
+                    if(failed_lock==next)
                    {
                        begin_lock.release();
+                        guard.release();
                        return;
                    }
                    start_with_begin=false;
@@ -1399,28 +1121,11 @@ namespace boost
                }
                else
                {
-                    detail::range_lock_guard<Iterator> guard(next,end);
-                    if(begin_lock.try_lock())
-                    {
-                        Iterator const failed_lock=try_lock(second,next);
-                        if(failed_lock==next)
-                        {
-                            begin_lock.release();
-                            guard.release();
-                            return;
-                        }
-                        start_with_begin=false;
-                        next=failed_lock;
-                    }
-                    else
-                    {
-                        start_with_begin=true;
-                        next=second;
-                    }
+                    start_with_begin=true;
+                    next=second;
                }
            }
        }
-        
    }
    
 }
--- a/include/boost/thread/pthread/condition_variable.hpp
+++ b/include/boost/thread/pthread/condition_variable.hpp
@@ -121,17 +121,6 @@ namespace boost
            }
            return true;
        }
-        template<typename lock_type>
-        bool timed_wait(lock_type& m,xtime const& wait_until)
-        {
-            return timed_wait(m,system_time(wait_until));
-        }
-
-        template<typename lock_type,typename duration_type>
-        bool timed_wait(lock_type& m,duration_type const& wait_duration)
-        {
-            return timed_wait(m,get_system_time()+wait_duration);
-        }

        template<typename lock_type,typename predicate_type>
        bool timed_wait(lock_type& m,boost::system_time const& wait_until,predicate_type pred)
--- a/include/boost/thread/pthread/condition_variable_fwd.hpp
+++ b/include/boost/thread/pthread/condition_variable_fwd.hpp
@@ -47,16 +47,6 @@ namespace boost
        }

        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)
-        {
-            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)
--- a/include/boost/thread/pthread/mutex.hpp
+++ b/include/boost/thread/pthread/mutex.hpp
@@ -10,7 +10,6 @@
 #include <boost/thread/exceptions.hpp>
 #include <boost/thread/locks.hpp>
 #include <boost/thread/thread_time.hpp>
-#include <boost/thread/xtime.hpp>
 #include <boost/assert.hpp>
 #include <errno.h>
 #include "timespec.hpp"
@@ -114,10 +113,6 @@ namespace boost
        {
            return timed_lock(get_system_time()+relative_time);
        }
-        bool timed_lock(boost::xtime const & absolute_time)
-        {
-            return timed_lock(system_time(absolute_time));
-        }

 #ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
        void lock()
--- a/include/boost/thread/pthread/recursive_mutex.hpp
+++ b/include/boost/thread/pthread/recursive_mutex.hpp
@@ -177,7 +177,7 @@ namespace boost
        {
            struct timespec const timeout=detail::get_timespec(abs_time);
            int const res=pthread_mutex_timedlock(&m,&timeout);
-            BOOST_ASSERT(!res || res==ETIMEDOUT);
+            BOOST_ASSERT(!res || res==EBUSY);
            return !res;
        }

--- a/include/boost/thread/pthread/shared_mutex.hpp
+++ b/include/boost/thread/pthread/shared_mutex.hpp
@@ -57,18 +57,18 @@ namespace boost
        void lock_shared()
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                
            while(state.exclusive || state.exclusive_waiting_blocked)
            {
-                shared_cond.wait(lk);
+                shared_cond.wait(lock);
            }
            ++state.shared_count;
        }

        bool try_lock_shared()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                
            if(state.exclusive || state.exclusive_waiting_blocked)
            {
@@ -84,11 +84,11 @@ namespace boost
        bool timed_lock_shared(system_time const& timeout)
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                
            while(state.exclusive || state.exclusive_waiting_blocked)
            {
-                if(!shared_cond.timed_wait(lk,timeout))
+                if(!shared_cond.timed_wait(lock,timeout))
                {
                    return false;
                }
@@ -105,7 +105,7 @@ namespace boost

        void unlock_shared()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            bool const last_reader=!--state.shared_count;
                
            if(last_reader)
@@ -127,12 +127,12 @@ namespace boost
        void lock()
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                
            while(state.shared_count || state.exclusive)
            {
                state.exclusive_waiting_blocked=true;
-                exclusive_cond.wait(lk);
+                exclusive_cond.wait(lock);
            }
            state.exclusive=true;
        }
@@ -140,12 +140,12 @@ namespace boost
        bool timed_lock(system_time const& timeout)
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);

            while(state.shared_count || state.exclusive)
            {
                state.exclusive_waiting_blocked=true;
-                if(!exclusive_cond.timed_wait(lk,timeout))
+                if(!exclusive_cond.timed_wait(lock,timeout))
                {
                    if(state.shared_count || state.exclusive)
                    {
@@ -168,7 +168,7 @@ namespace boost

        bool try_lock()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                
            if(state.shared_count || state.exclusive)
            {
@@ -184,7 +184,7 @@ namespace boost

        void unlock()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            state.exclusive=false;
            state.exclusive_waiting_blocked=false;
            release_waiters();
@@ -193,10 +193,10 @@ namespace boost
        void lock_upgrade()
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
-                shared_cond.wait(lk);
+                shared_cond.wait(lock);
            }
            ++state.shared_count;
            state.upgrade=true;
@@ -205,10 +205,10 @@ namespace boost
        bool timed_lock_upgrade(system_time const& timeout)
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
-                if(!shared_cond.timed_wait(lk,timeout))
+                if(!shared_cond.timed_wait(lock,timeout))
                {
                    if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
                    {
@@ -230,7 +230,7 @@ namespace boost

        bool try_lock_upgrade()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
                return false;
@@ -245,7 +245,7 @@ namespace boost

        void unlock_upgrade()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            state.upgrade=false;
            bool const last_reader=!--state.shared_count;
                
@@ -259,11 +259,11 @@ namespace boost
        void unlock_upgrade_and_lock()
        {
            boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            --state.shared_count;
            while(state.shared_count)
            {
-                upgrade_cond.wait(lk);
+                upgrade_cond.wait(lock);
            }
            state.upgrade=false;
            state.exclusive=true;
@@ -271,7 +271,7 @@ namespace boost

        void unlock_and_lock_upgrade()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            state.exclusive=false;
            state.upgrade=true;
            ++state.shared_count;
@@ -281,7 +281,7 @@ namespace boost
        
        void unlock_and_lock_shared()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            state.exclusive=false;
            ++state.shared_count;
            state.exclusive_waiting_blocked=false;
@@ -290,7 +290,7 @@ namespace boost
        
        void unlock_upgrade_and_lock_shared()
        {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
            state.upgrade=false;
            state.exclusive_waiting_blocked=false;
            release_waiters();
--- a/include/boost/thread/tss.hpp
+++ b/include/boost/thread/tss.hpp
@@ -1,111 +1,110 @@
-#ifndef BOOST_THREAD_TSS_HPP
-#define BOOST_THREAD_TSS_HPP
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// (C) Copyright 2007-8 Anthony Williams
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/thread/detail/thread_heap_alloc.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-    namespace detail
-    {
-        struct tss_cleanup_function
-        {
-            virtual ~tss_cleanup_function()
-            {}
-            
-            virtual void operator()(void* data)=0;
-        };
-        
-        BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
-        BOOST_THREAD_DECL void* get_tss_data(void const* key);
-    }
-
-    template <typename T>
-    class thread_specific_ptr
-    {
-    private:
-        thread_specific_ptr(thread_specific_ptr&);
-        thread_specific_ptr& operator=(thread_specific_ptr&);
-
-        struct delete_data:
-            detail::tss_cleanup_function
-        {
-            void operator()(void* data)
-            {
-                delete static_cast<T*>(data);
-            }
-        };
-        
-        struct run_custom_cleanup_function:
-            detail::tss_cleanup_function
-        {
-            void (*cleanup_function)(T*);
-            
-            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
-                cleanup_function(cleanup_function_)
-            {}
-            
-            void operator()(void* data)
-            {
-                cleanup_function(static_cast<T*>(data));
-            }
-        };
-
-
-        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
-        
-    public:
-        thread_specific_ptr():
-            cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
-        {}
-        explicit thread_specific_ptr(void (*func_)(T*))
-        {
-            if(func_)
-            {
-                cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
-            }
-        }
-        ~thread_specific_ptr()
-        {
-            reset();
-        }
-
-        T* get() const
-        {
-            return static_cast<T*>(detail::get_tss_data(this));
-        }
-        T* operator->() const
-        {
-            return get();
-        }
-        T& operator*() const
-        {
-            return *get();
-        }
-        T* release()
-        {
-            T* const temp=get();
-            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
-            return temp;
-        }
-        void reset(T* new_value=0)
-        {
-            T* const current_value=get();
-            if(current_value!=new_value)
-            {
-                detail::set_tss_data(this,cleanup,new_value,true);
-            }
-        }
-    };
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
+#ifndef BOOST_THREAD_TSS_HPP
+#define BOOST_THREAD_TSS_HPP
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007-8 Anthony Williams
+
+#include <boost/shared_ptr.hpp>
+#include <boost/thread/detail/thread_heap_alloc.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        struct tss_cleanup_function
+        {
+            virtual ~tss_cleanup_function()
+            {}
+            
+            virtual void operator()(void* data)=0;
+        };
+        
+        BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
+        BOOST_THREAD_DECL void* get_tss_data(void const* key);
+    }
+
+    template <typename T>
+    class thread_specific_ptr
+    {
+    private:
+        thread_specific_ptr(thread_specific_ptr&);
+        thread_specific_ptr& operator=(thread_specific_ptr&);
+
+        struct delete_data:
+            detail::tss_cleanup_function
+        {
+            void operator()(void* data)
+            {
+                delete static_cast<T*>(data);
+            }
+        };
+        
+        struct run_custom_cleanup_function:
+            detail::tss_cleanup_function
+        {
+            void (*cleanup_function)(T*);
+            
+            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
+                cleanup_function(cleanup_function_)
+            {}
+            
+            void operator()(void* data)
+            {
+                cleanup_function(static_cast<T*>(data));
+            }
+        };
+
+
+        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
+        
+    public:
+        thread_specific_ptr():
+            cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
+        {}
+        explicit thread_specific_ptr(void (*func_)(T*))
+        {
+            if(func_)
+            {
+                cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
+            }
+        }
+        ~thread_specific_ptr()
+        {
+            reset();
+        }
+
+        T* get() const
+        {
+            return static_cast<T*>(detail::get_tss_data(this));
+        }
+        T* operator->() const
+        {
+            return get();
+        }
+        T& operator*() const
+        {
+            return *get();
+        }
+        T* release()
+        {
+            T* const temp=get();
+            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
+            return temp;
+        }
+        void reset(T* new_value=0)
+        {
+            T* const current_value=get();
+            if(current_value!=new_value)
+            {
+                detail::set_tss_data(this,cleanup,new_value,true);
+            }
+        }
+    };
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif
--- a/include/boost/thread/win32/basic_recursive_mutex.hpp
+++ b/include/boost/thread/win32/basic_recursive_mutex.hpp
@@ -64,6 +64,11 @@ namespace boost
                return timed_lock(get_system_time()+timeout);
            }

+            long get_active_count()
+            {
+                return mutex.get_active_count();
+            }
+
            void unlock()
            {
                if(!--recursion_count)
@@ -73,6 +78,11 @@ namespace boost
                }
            }

+            bool locked()
+            {
+                return mutex.locked();
+            }
+            
        private:
            bool try_recursive_lock(long current_thread_id)
            {
--- a/include/boost/thread/win32/basic_timed_mutex.hpp
+++ b/include/boost/thread/win32/basic_timed_mutex.hpp
@@ -13,7 +13,6 @@
 #include "thread_primitives.hpp"
 #include "interlocked_read.hpp"
 #include <boost/thread/thread_time.hpp>
-#include <boost/thread/xtime.hpp>
 #include <boost/detail/interlocked.hpp>

 #include <boost/config/abi_prefix.hpp>
@@ -118,9 +117,9 @@ namespace boost
                return timed_lock(get_system_time()+timeout);
            }

-            bool timed_lock(boost::xtime const& timeout)
+            long get_active_count()
            {
-                return timed_lock(system_time(timeout));
+                return ::boost::detail::interlocked_read_acquire(&active_count);
            }

            void unlock()
@@ -136,6 +135,11 @@ namespace boost
                }
            }

+            bool locked()
+            {
+                return get_active_count()>=lock_flag_value;
+            }
+            
        private:
            void* get_event()
            {
--- a/include/boost/thread/win32/mutex.hpp
+++ b/include/boost/thread/win32/mutex.hpp
@@ -20,7 +20,7 @@ namespace boost
    }

    class mutex:
-        boost::noncopyable,
+		boost::noncopyable,
        public ::boost::detail::underlying_mutex
    {
    public:
--- a/include/boost/thread/win32/shared_mutex.hpp
+++ b/include/boost/thread/win32/shared_mutex.hpp
@@ -91,7 +91,7 @@ namespace boost
        bool try_lock_shared()
        {
            state_data old_state=state;
-            for(;;)
+            do
            {
                state_data new_state=old_state;
                if(!new_state.exclusive && !new_state.exclusive_waiting_blocked)
@@ -106,6 +106,14 @@ namespace boost
                }
                old_state=current_state;
            }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
            return !(old_state.exclusive| old_state.exclusive_waiting_blocked);
        }

@@ -122,10 +130,17 @@ namespace boost

        bool timed_lock_shared(boost::system_time const& wait_until)
        {
-            for(;;)
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true)
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
            {
                state_data old_state=state;
-                for(;;)
+                do
                {
                    state_data new_state=old_state;
                    if(new_state.exclusive || new_state.exclusive_waiting_blocked)
@@ -144,6 +159,14 @@ namespace boost
                    }
                    old_state=current_state;
                }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+                while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

                if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
                {
@@ -153,7 +176,7 @@ namespace boost
                unsigned long const res=detail::win32::WaitForSingleObject(unlock_sem,::boost::detail::get_milliseconds_until(wait_until));
                if(res==detail::win32::timeout)
                {
-                    for(;;)
+                    do
                    {
                        state_data new_state=old_state;
                        if(new_state.exclusive || new_state.exclusive_waiting_blocked)
@@ -175,6 +198,14 @@ namespace boost
                        }
                        old_state=current_state;
                    }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+                    while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

                    if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
                    {
@@ -190,7 +221,7 @@ namespace boost
        void unlock_shared()
        {
            state_data old_state=state;
-            for(;;)
+            do
            {
                state_data new_state=old_state;
                bool const last_reader=!--new_state.shared_count;
@@ -231,6 +262,14 @@ namespace boost
                }
                old_state=current_state;
            }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
        }

        void lock()
@@ -244,39 +283,20 @@ namespace boost
            return timed_lock(get_system_time()+relative_time);
        }

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

-                for(;;)
+                do
                {
                    state_data new_state=old_state;
                    if(new_state.shared_count || new_state.exclusive)
@@ -296,6 +316,14 @@ namespace boost
                    }
                    old_state=current_state;
                }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+                while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

                if(!old_state.shared_count && !old_state.exclusive)
                {
@@ -304,7 +332,7 @@ namespace boost
                unsigned long const wait_res=detail::win32::WaitForMultipleObjects(2,semaphores,true,::boost::detail::get_milliseconds_until(wait_until));
                if(wait_res==detail::win32::timeout)
                {
-                    for(;;)
+                    do
                    {
                        state_data new_state=old_state;
                        if(new_state.shared_count || new_state.exclusive)
@@ -329,6 +357,14 @@ namespace boost
                        }
                        old_state=current_state;
                    }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+                    while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
                    if(!old_state.shared_count && !old_state.exclusive)
                    {
                        return true;
@@ -342,7 +378,7 @@ namespace boost
        void unlock()
        {
            state_data old_state=state;
-            for(;;)
+            do
            {
                state_data new_state=old_state;
                new_state.exclusive=false;
@@ -360,15 +396,30 @@ namespace boost
                }
                old_state=current_state;
            }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
            release_waiters(old_state);
        }

        void lock_upgrade()
        {
-            for(;;)
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true)
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
            {
                state_data old_state=state;
-                for(;;)
+                do
                {
                    state_data new_state=old_state;
                    if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
@@ -388,6 +439,14 @@ namespace boost
                    }
                    old_state=current_state;
                }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+                while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

                if(!(old_state.exclusive|| old_state.exclusive_waiting_blocked|| old_state.upgrade))
                {
@@ -398,36 +457,10 @@ namespace boost
            }
        }

-        bool try_lock_upgrade()
-        {
-            state_data old_state=state;
-            for(;;)
-            {
-                state_data new_state=old_state;
-                if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
-                {
-                    return false;
-                }
-                else
-                {
-                    ++new_state.shared_count;
-                    new_state.upgrade=true;
-                }
-                
-                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
-                if(current_state==old_state)
-                {
-                    break;
-                }
-                old_state=current_state;
-            }
-            return true;
-        }
-
        void unlock_upgrade()
        {
            state_data old_state=state;
-            for(;;)
+            do
            {
                state_data new_state=old_state;
                new_state.upgrade=false;
@@ -454,12 +487,20 @@ namespace boost
                }
                old_state=current_state;
            }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
        }

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

        void unlock_and_lock_upgrade()
        {
            state_data old_state=state;
-            for(;;)
+            do
            {
                state_data new_state=old_state;
                new_state.exclusive=false;
@@ -506,13 +555,21 @@ namespace boost
                }
                old_state=current_state;
            }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
            release_waiters(old_state);
        }
        
        void unlock_and_lock_shared()
        {
            state_data old_state=state;
-            for(;;)
+            do
            {
                state_data new_state=old_state;
                new_state.exclusive=false;
@@ -531,13 +588,21 @@ namespace boost
                }
                old_state=current_state;
            }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
            release_waiters(old_state);
        }
        
        void unlock_upgrade_and_lock_shared()
        {
            state_data old_state=state;
-            for(;;)
+            do
            {
                state_data new_state=old_state;
                new_state.upgrade=false;
@@ -555,6 +620,14 @@ namespace boost
                }
                old_state=current_state;
            }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+            while(true);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
            release_waiters(old_state);
        }
        
--- a/include/boost/thread/win32/thread_primitives.hpp
+++ b/include/boost/thread/win32/thread_primitives.hpp
@@ -64,7 +64,7 @@ namespace boost
 # ifdef UNDER_CE
 #  ifndef WINAPI
 #   ifndef _WIN32_WCE_EMULATION
-#    define WINAPI  __cdecl     // Note this doesn't match the desktop definition
+#    define WINAPI  __cdecl	// Note this doesn't match the desktop definition
 #   else
 #    define WINAPI  __stdcall
 #   endif
@@ -282,6 +282,16 @@ namespace boost
 }

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

 namespace boost
 {
@@ -289,17 +299,6 @@ namespace boost
    {
        namespace win32
        {
-#if _MSC_VER==1400
-            extern "C" unsigned char _interlockedbittestandset(long *a,long b);
-            extern "C" unsigned char _interlockedbittestandreset(long *a,long b);
-#else
-            extern "C" unsigned char _interlockedbittestandset(volatile long *a,long b);
-            extern "C" unsigned char _interlockedbittestandreset(volatile long *a,long b);
-#endif
-
-#pragma intrinsic(_interlockedbittestandset)
-#pragma intrinsic(_interlockedbittestandreset)
-
            inline bool interlocked_bit_test_and_set(long* x,long bit)
            {
                return _interlockedbittestandset(x,bit)!=0;
--- a/module.cmake
+++ b/module.cmake
@@ -1 +0,0 @@
-boost_module(thread DEPENDS date_time bind optional range)
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,15 +0,0 @@
-if (WIN32)
-  set(THREAD_SOURCES win32/thread.cpp win32/exceptions.cpp win32/tss_dll.cpp
-                     win32/tss_pe.cpp)
-else (WIN32)
-  set(THREAD_SOURCES pthread/thread.cpp pthread/exceptions.cpp pthread/once.cpp)
-endif (WIN32)
-
-boost_add_library(
-  boost_thread
-  ${THREAD_SOURCES}
-  SHARED_COMPILE_FLAGS "-DBOOST_THREAD_BUILD_DLL=1"
-  STATIC_COMPILE_FLAGS "-DBOOST_THREAD_BUILD_LIB=1"
-  NO_SINGLE_THREADED
-  )
-
--- a/src/pthread/thread.cpp
+++ b/src/pthread/thread.cpp
@@ -18,7 +18,7 @@
 #elif defined(__APPLE__) || defined(__FreeBSD__)
 #include <sys/types.h>
 #include <sys/sysctl.h>
-#elif defined BOOST_HAS_UNISTD_H
+#elif defined(__sun) || defined(__CYGWIN__)
 #include <unistd.h>
 #endif

@@ -132,12 +132,10 @@ namespace boost
                catch(thread_interrupted const&)
                {
                }
-// Removed as it stops the debugger identifying the cause of the exception
-// Unhandled exceptions still cause the application to terminate
-//                 catch(...)
-//                 {
-//                     std::terminate();
-//                 }
+                catch(...)
+                {
+                    std::terminate();
+                }

                detail::tls_destructor(thread_info.get());
                detail::set_current_thread_data(0);
@@ -396,7 +394,7 @@ namespace boost
        int count;
        size_t size=sizeof(count);
        return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
-#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
+#elif defined(__sun) || defined(__CYGWIN__)
        int const count=sysconf(_SC_NPROCESSORS_ONLN);
        return (count>0)?count:0;
 #else
--- a/src/win32/thread.cpp
+++ b/src/win32/thread.cpp
@@ -29,26 +29,13 @@ namespace boost

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

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

@@ -154,8 +141,8 @@ namespace boost
                    }
                }
                
-                set_current_thread_data(0);
            }
+            set_current_thread_data(0);
        }
        
        unsigned __stdcall thread_start_function(void* param)
@@ -169,12 +156,10 @@ namespace boost
            catch(thread_interrupted const&)
            {
            }
-// Removed as it stops the debugger identifying the cause of the exception
-// Unhandled exceptions still cause the application to terminate
-//             catch(...)
-//             {
-//                 std::terminate();
-//             }
+            catch(...)
+            {
+                std::terminate();
+            }
            run_thread_exit_callbacks();
            return 0;
        }
@@ -559,6 +544,7 @@ namespace boost
        
        void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing)
        {
+            tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in
            if(tss_data_node* const current_node=find_tss_data(key))
            {
                if(cleanup_existing && current_node->func.get())
@@ -586,9 +572,7 @@ extern "C" BOOST_THREAD_DECL void on_thread_enter()
 {}

 extern "C" BOOST_THREAD_DECL void on_process_exit()
-{
-    boost::cleanup_tls_key();
-}
+{}

 extern "C" BOOST_THREAD_DECL void on_thread_exit()
 {
--- a/src/win32/tss_pe.cpp
+++ b/src/win32/tss_pe.cpp
@@ -26,11 +26,11 @@ namespace {
    {
        switch (dwReason)
        {
-        case DLL_THREAD_DETACH:
-        {
-            on_thread_exit();
-            break;
-        }
+            case DLL_THREAD_DETACH:
+            {
+                on_thread_exit();
+                break;
+            }
        }
    }

@@ -125,10 +125,10 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma section(".CRT$XCU",long,read)
 #pragma section(".CRT$XTU",long,read)
 #pragma section(".CRT$XLC",long,read)
-        __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
-        __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
-        __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
-        __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
+        static __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
+        static __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
+        static __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
+        static __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
 #else
        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
        #   pragma data_seg(push, old_seg)
@@ -168,7 +168,6 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma warning(push)
 #pragma warning(disable:4189)
 #endif
-
        PVAPI on_tls_prepare(void)
        {
            //The following line has an important side effect:
@@ -240,32 +239,15 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
        {
            switch (dwReason)
            {
-            case DLL_THREAD_DETACH:
-                on_thread_exit();
-                break;
+                case DLL_THREAD_DETACH:
+                {
+                    on_thread_exit();
+                    break;
+                }
            }
        }
-
-        BOOL WINAPI dll_callback(HANDLE, DWORD dwReason, LPVOID)
-        {
-            switch (dwReason)
-            {
-            case DLL_THREAD_DETACH:
-                on_thread_exit();
-                break;
-            case DLL_PROCESS_DETACH:
-                on_process_exit();
-                break;
-            }
-            return true;
-        }
    } //namespace

-extern "C"
-{
-    extern BOOL (WINAPI * const _pRawDllMain)(HANDLE, DWORD, LPVOID)=&dll_callback;
-}
-
    extern "C" void tss_cleanup_implemented(void)
    {
        /*
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,33 +0,0 @@
-boost_additional_test_dependencies(thread BOOST_DEPENDS test )
-
-
-
-set(TESTS 
-test_thread
-test_thread_id
-test_hardware_concurrency
-test_thread_move
-test_thread_launching
-test_thread_mf
-test_move_function
-test_mutex
-test_condition_notify_one
-test_condition_timed_wait_times_out
-test_condition_notify_all
-test_condition
-test_tss
-test_once
-test_xtime
-test_barrier
-test_shared_mutex
-test_shared_mutex_part_2
-test_shared_mutex_timed_locks
-test_lock_concept
-test_generic_locks)
-
-foreach (TEST ${TESTS})
-  boost_test_run(${TEST} MULTI_THREADED DEPENDS boost_thread boost_unit_test_framework)
-endforeach (TEST ${TESTS})
-
-boost_test_compile_fail(no_implicit_move_from_lvalue_thread)
-boost_test_compile_fail(no_implicit_assign_from_lvalue_thread)
--- a/test/test_condition_timed_wait_times_out.cpp
+++ b/test/test_condition_timed_wait_times_out.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-8 Anthony Williams
+// Copyright (C) 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)
@@ -16,7 +16,7 @@ bool fake_predicate()
    return false;
 }

-unsigned const timeout_seconds=2;
+unsigned const timeout_seconds=5;
 unsigned const timeout_grace=1;
 boost::posix_time::milliseconds const timeout_resolution(100);

@@ -70,96 +70,12 @@ void do_test_relative_timed_wait_with_predicate_times_out()
    BOOST_CHECK((delay-timeout_resolution)<=(end-start));
 }

-void do_test_timed_wait_relative_times_out()
-{
-    boost::condition_variable cond;
-    boost::mutex m;
-
-    boost::posix_time::seconds const delay(timeout_seconds);
-    boost::mutex::scoped_lock lock(m);
-    boost::system_time const start=boost::get_system_time();
-
-    while(cond.timed_wait(lock,delay));
-
-    boost::system_time const end=boost::get_system_time();
-    BOOST_CHECK((delay-timeout_resolution)<=(end-start));
-}
-
-void do_test_cv_any_timed_wait_times_out()
-{
-    boost::condition_variable_any cond;
-    boost::mutex m;
-
-    boost::posix_time::seconds const delay(timeout_seconds);
-    boost::mutex::scoped_lock lock(m);
-    boost::system_time const start=boost::get_system_time();
-    boost::system_time const timeout=start+delay;
-
-    while(cond.timed_wait(lock,timeout));
-
-    boost::system_time const end=boost::get_system_time();
-    BOOST_CHECK((delay-timeout_resolution)<=(end-start));
-}
-
-void do_test_cv_any_timed_wait_with_predicate_times_out()
-{
-    boost::condition_variable_any cond;
-    boost::mutex m;
-
-    boost::posix_time::seconds const delay(timeout_seconds);
-    boost::mutex::scoped_lock lock(m);
-    boost::system_time const start=boost::get_system_time();
-    boost::system_time const timeout=start+delay;
-
-    bool const res=cond.timed_wait(lock,timeout,fake_predicate);
-
-    boost::system_time const end=boost::get_system_time();
-    BOOST_CHECK(!res);
-    BOOST_CHECK((delay-timeout_resolution)<=(end-start));
-}
-
-void do_test_cv_any_relative_timed_wait_with_predicate_times_out()
-{
-    boost::condition_variable_any cond;
-    boost::mutex m;
-
-    boost::posix_time::seconds const delay(timeout_seconds);
-    boost::mutex::scoped_lock lock(m);
-    boost::system_time const start=boost::get_system_time();
-
-    bool const res=cond.timed_wait(lock,delay,fake_predicate);
-
-    boost::system_time const end=boost::get_system_time();
-    BOOST_CHECK(!res);
-    BOOST_CHECK((delay-timeout_resolution)<=(end-start));
-}
-
-void do_test_cv_any_timed_wait_relative_times_out()
-{
-    boost::condition_variable_any cond;
-    boost::mutex m;
-
-    boost::posix_time::seconds const delay(timeout_seconds);
-    boost::mutex::scoped_lock lock(m);
-    boost::system_time const start=boost::get_system_time();
-
-    while(cond.timed_wait(lock,delay));
-
-    boost::system_time const end=boost::get_system_time();
-    BOOST_CHECK((delay-timeout_resolution)<=(end-start));
-}
-

 void test_timed_wait_times_out()
 {
    timed_test(&do_test_timed_wait_times_out, timeout_seconds+timeout_grace, execution_monitor::use_mutex);
    timed_test(&do_test_timed_wait_with_predicate_times_out, timeout_seconds+timeout_grace, execution_monitor::use_mutex);
    timed_test(&do_test_relative_timed_wait_with_predicate_times_out, timeout_seconds+timeout_grace, execution_monitor::use_mutex);
-    timed_test(&do_test_timed_wait_relative_times_out, timeout_seconds+timeout_grace, execution_monitor::use_mutex);
-    timed_test(&do_test_cv_any_timed_wait_times_out, timeout_seconds+timeout_grace, execution_monitor::use_mutex);
-    timed_test(&do_test_cv_any_timed_wait_with_predicate_times_out, timeout_seconds+timeout_grace, execution_monitor::use_mutex);
-    timed_test(&do_test_cv_any_relative_timed_wait_with_predicate_times_out, timeout_seconds+timeout_grace, execution_monitor::use_mutex);
-    timed_test(&do_test_cv_any_timed_wait_relative_times_out, timeout_seconds+timeout_grace, execution_monitor::use_mutex);
 }

 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
--- a/test/test_generic_locks.cpp
+++ b/test/test_generic_locks.cpp
@@ -272,16 +272,6 @@ struct dummy_mutex
    }
 };

-namespace boost
-{
-    template<>
-    struct is_mutex_type<dummy_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-}
-
-

 void test_lock_five_in_range()
 {
--- a/test/test_lock_concept.cpp
+++ b/test/test_lock_concept.cpp
@@ -7,7 +7,6 @@
 #include <boost/test/test_case_template.hpp>
 #include <boost/mpl/vector.hpp>
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
@@ -83,122 +82,6 @@ struct test_initially_unlocked_if_other_thread_has_lock
    }
 };

-template<typename Mutex,typename Lock>
-struct test_initially_unlocked_with_try_lock_if_other_thread_has_unique_lock
-{
-    Mutex m;
-    boost::mutex done_mutex;
-    bool done;
-    bool locked;
-    boost::condition_variable done_cond;
-    
-    test_initially_unlocked_with_try_lock_if_other_thread_has_unique_lock():
-        done(false),locked(false)
-    {}
-
-    void locking_thread()
-    {
-        Lock lock(m,boost::try_to_lock);
-
-        boost::lock_guard<boost::mutex> lk(done_mutex);
-        locked=lock.owns_lock();
-        done=true;
-        done_cond.notify_one();
-    }
-
-    bool is_done() const
-    {
-        return done;
-    }
-    
-
-    void operator()()
-    {
-        boost::unique_lock<Mutex> lock(m);
-
-        typedef test_initially_unlocked_with_try_lock_if_other_thread_has_unique_lock<Mutex,Lock> this_type;
-
-        boost::thread t(&this_type::locking_thread,this);
-
-        try
-        {
-            {
-                boost::mutex::scoped_lock lk(done_mutex);
-                BOOST_CHECK(done_cond.timed_wait(lk,boost::posix_time::seconds(2),
-                                                 boost::bind(&this_type::is_done,this)));
-                BOOST_CHECK(!locked);
-            }
-            
-            lock.unlock();
-            t.join();
-        }
-        catch(...)
-        {
-            lock.unlock();
-            t.join();
-            throw;
-        }
-    }
-};
-
-template<typename Mutex,typename Lock>
-struct test_initially_locked_if_other_thread_has_shared_lock
-{
-    Mutex m;
-    boost::mutex done_mutex;
-    bool done;
-    bool locked;
-    boost::condition_variable done_cond;
-    
-    test_initially_locked_if_other_thread_has_shared_lock():
-        done(false),locked(false)
-    {}
-
-    void locking_thread()
-    {
-        Lock lock(m);
-
-        boost::lock_guard<boost::mutex> lk(done_mutex);
-        locked=lock.owns_lock();
-        done=true;
-        done_cond.notify_one();
-    }
-
-    bool is_done() const
-    {
-        return done;
-    }
-    
-
-    void operator()()
-    {
-        boost::shared_lock<Mutex> lock(m);
-
-        typedef test_initially_locked_if_other_thread_has_shared_lock<Mutex,Lock> this_type;
-
-        boost::thread t(&this_type::locking_thread,this);
-
-        try
-        {
-            {
-                boost::mutex::scoped_lock lk(done_mutex);
-                BOOST_CHECK(done_cond.timed_wait(lk,boost::posix_time::seconds(2),
-                                                 boost::bind(&this_type::is_done,this)));
-                BOOST_CHECK(locked);
-            }
-            
-            lock.unlock();
-            t.join();
-        }
-        catch(...)
-        {
-            lock.unlock();
-            t.join();
-            throw;
-        }
-    }
-};
-
 template<typename Mutex,typename Lock>
 struct test_initially_unlocked_with_defer_lock_parameter
 {
@@ -266,64 +149,6 @@ struct test_locked_after_try_lock_called
    }
 };

-template<typename Mutex,typename Lock>
-struct test_unlocked_after_try_lock_if_other_thread_has_lock
-{
-    Mutex m;
-    boost::mutex done_mutex;
-    bool done;
-    bool locked;
-    boost::condition_variable done_cond;
-    
-    test_unlocked_after_try_lock_if_other_thread_has_lock():
-        done(false),locked(false)
-    {}
-
-    void locking_thread()
-    {
-        Lock lock(m,boost::defer_lock);
-
-        boost::lock_guard<boost::mutex> lk(done_mutex);
-        locked=lock.owns_lock();
-        done=true;
-        done_cond.notify_one();
-    }
-
-    bool is_done() const
-    {
-        return done;
-    }
-    
-
-    void operator()()
-    {
-        Lock lock(m);
-
-        typedef test_unlocked_after_try_lock_if_other_thread_has_lock<Mutex,Lock> this_type;
-
-        boost::thread t(&this_type::locking_thread,this);
-
-        try
-        {
-            {
-                boost::mutex::scoped_lock lk(done_mutex);
-                BOOST_CHECK(done_cond.timed_wait(lk,boost::posix_time::seconds(2),
-                                                 boost::bind(&this_type::is_done,this)));
-                BOOST_CHECK(!locked);
-            }
-            
-            lock.unlock();
-            t.join();
-        }
-        catch(...)
-        {
-            lock.unlock();
-            t.join();
-            throw;
-        }
-    }
-};
-
 template<typename Mutex,typename Lock>
 struct test_throws_if_lock_called_when_already_locked
 {
@@ -379,8 +204,6 @@ struct test_locks_can_be_swapped
    {
        Mutex m1;
        Mutex m2;
-        Mutex m3;
-
        Lock l1(m1);
        Lock l2(m2);

@@ -396,16 +219,16 @@ struct test_locks_can_be_swapped

        BOOST_CHECK_EQUAL(l1.mutex(),&m1);
        BOOST_CHECK_EQUAL(l2.mutex(),&m2);
-
-        l1.swap(Lock(m3));
-
-        BOOST_CHECK_EQUAL(l1.mutex(),&m3);
+        
    }
 };

-template<typename Mutex,typename Lock>
-void test_lock_is_scoped_lock_concept_for_mutex()
+
+
+BOOST_TEST_CASE_TEMPLATE_FUNCTION(test_scoped_lock_concept,Mutex)
 {
+    typedef typename Mutex::scoped_lock Lock;
+    
    test_default_constructed_has_no_mutex_and_unlocked<Lock>()();
    test_initially_locked<Mutex,Lock>()();
    test_initially_unlocked_with_defer_lock_parameter<Mutex,Lock>()();
@@ -415,24 +238,6 @@ void test_lock_is_scoped_lock_concept_for_mutex()
    test_throws_if_lock_called_when_already_locked<Mutex,Lock>()();
    test_throws_if_unlock_called_when_already_unlocked<Mutex,Lock>()();
    test_locks_can_be_swapped<Mutex,Lock>()();
-    test_locked_after_try_lock_called<Mutex,Lock>()();
-    test_throws_if_try_lock_called_when_already_locked<Mutex,Lock>()();
-    test_unlocked_after_try_lock_if_other_thread_has_lock<Mutex,Lock>()();
-}
-
-
-BOOST_TEST_CASE_TEMPLATE_FUNCTION(test_scoped_lock_concept,Mutex)
-{
-    typedef typename Mutex::scoped_lock Lock;
-
-    test_lock_is_scoped_lock_concept_for_mutex<Mutex,Lock>();
-}
-
-BOOST_TEST_CASE_TEMPLATE_FUNCTION(test_unique_lock_is_scoped_lock,Mutex)
-{
-    typedef boost::unique_lock<Mutex> Lock;
-
-    test_lock_is_scoped_lock_concept_for_mutex<Mutex,Lock>();
 }

 BOOST_TEST_CASE_TEMPLATE_FUNCTION(test_scoped_try_lock_concept,Mutex)
@@ -447,125 +252,26 @@ BOOST_TEST_CASE_TEMPLATE_FUNCTION(test_scoped_try_lock_concept,Mutex)
    test_unlocked_after_unlock_called<Mutex,Lock>()();
    test_locked_after_lock_called<Mutex,Lock>()();
    test_locked_after_try_lock_called<Mutex,Lock>()();
-    test_unlocked_after_try_lock_if_other_thread_has_lock<Mutex,Lock>()();
    test_throws_if_lock_called_when_already_locked<Mutex,Lock>()();
    test_throws_if_try_lock_called_when_already_locked<Mutex,Lock>()();
    test_throws_if_unlock_called_when_already_unlocked<Mutex,Lock>()();
    test_locks_can_be_swapped<Mutex,Lock>()();
 }

-struct dummy_shared_mutex
-{
-    bool locked;
-    bool shared_locked;
-    bool shared_unlocked;
-    bool shared_timed_locked_relative;
-    bool shared_timed_locked_absolute;
-    bool timed_locked_relative;
-    bool timed_locked_absolute;
-
-    dummy_shared_mutex():
-        locked(false),shared_locked(false),shared_unlocked(false),
-        shared_timed_locked_relative(false),
-        shared_timed_locked_absolute(false),
-        timed_locked_relative(false),
-        timed_locked_absolute(false)
-    {}
-    
-    void lock()
-    {
-        locked=true;
-    }
-    
-    void lock_shared()
-    {
-        shared_locked=true;
-    }
-    
-    void unlock()
-    {}
-    
-    void unlock_shared()
-    {
-        shared_unlocked=true;
-    }
-    
-    bool timed_lock_shared(boost::system_time)
-    {
-        shared_timed_locked_absolute=true;
-        return false;
-    }
-    template<typename Duration>
-    bool timed_lock_shared(Duration)
-    {
-        shared_timed_locked_relative=true;
-        return false;
-    }
-    bool timed_lock(boost::system_time)
-    {
-        timed_locked_absolute=true;
-        return false;
-    }
-    template<typename Duration>
-    bool timed_lock(Duration)
-    {
-        timed_locked_relative=true;
-        return false;
-    }
-    
-};
-
-
-void test_shared_lock()
-{
-    typedef boost::shared_mutex Mutex;
-    typedef boost::shared_lock<Mutex> Lock;
-    
-    test_default_constructed_has_no_mutex_and_unlocked<Lock>()();
-    test_initially_locked<Mutex,Lock>()();
-    test_initially_unlocked_with_try_lock_if_other_thread_has_unique_lock<Mutex,Lock>()();
-    test_initially_locked_if_other_thread_has_shared_lock<Mutex,Lock>()();
-    test_initially_unlocked_with_defer_lock_parameter<Mutex,Lock>()();
-    test_initially_locked_with_adopt_lock_parameter<Mutex,Lock>()();
-    test_unlocked_after_unlock_called<Mutex,Lock>()();
-    test_locked_after_lock_called<Mutex,Lock>()();
-    test_locked_after_try_lock_called<Mutex,Lock>()();
-    test_throws_if_lock_called_when_already_locked<Mutex,Lock>()();
-    test_throws_if_try_lock_called_when_already_locked<Mutex,Lock>()();
-    test_throws_if_unlock_called_when_already_unlocked<Mutex,Lock>()();
-    test_locks_can_be_swapped<Mutex,Lock>()();
-
-    dummy_shared_mutex dummy;
-    boost::shared_lock<dummy_shared_mutex> lk(dummy);
-    BOOST_CHECK(dummy.shared_locked);
-    lk.unlock();
-    BOOST_CHECK(dummy.shared_unlocked);
-    lk.timed_lock(boost::posix_time::milliseconds(5));
-    BOOST_CHECK(dummy.shared_timed_locked_relative);
-    lk.timed_lock(boost::get_system_time());
-    BOOST_CHECK(dummy.shared_timed_locked_absolute);
-}
-
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
    boost::unit_test_framework::test_suite* test =
        BOOST_TEST_SUITE("Boost.Threads: lock concept test suite");

    typedef boost::mpl::vector<boost::mutex,boost::try_mutex,boost::timed_mutex,
-        boost::recursive_mutex,boost::recursive_try_mutex,boost::recursive_timed_mutex> mutex_types_with_scoped_lock;
+        boost::recursive_mutex,boost::recursive_try_mutex,boost::recursive_timed_mutex> mutex_types;
    
-    test->add(BOOST_TEST_CASE_TEMPLATE(test_scoped_lock_concept,mutex_types_with_scoped_lock));
+    test->add(BOOST_TEST_CASE_TEMPLATE(test_scoped_lock_concept,mutex_types));

    typedef boost::mpl::vector<boost::try_mutex,boost::timed_mutex,
-        boost::recursive_try_mutex,boost::recursive_timed_mutex> mutex_types_with_scoped_try_lock;
+        boost::recursive_try_mutex,boost::recursive_timed_mutex> try_mutex_types;

-    test->add(BOOST_TEST_CASE_TEMPLATE(test_scoped_try_lock_concept,mutex_types_with_scoped_try_lock));
-
-    typedef boost::mpl::vector<boost::mutex,boost::try_mutex,boost::timed_mutex,
-        boost::recursive_mutex,boost::recursive_try_mutex,boost::recursive_timed_mutex,boost::shared_mutex> all_mutex_types;
-    
-    test->add(BOOST_TEST_CASE_TEMPLATE(test_unique_lock_is_scoped_lock,all_mutex_types));
-    test->add(BOOST_TEST_CASE(&test_shared_lock));
+    test->add(BOOST_TEST_CASE_TEMPLATE(test_scoped_try_lock_concept,try_mutex_types));

    return test;
 }
--- a/test/test_mutex.cpp
+++ b/test/test_mutex.cpp
@@ -7,7 +7,6 @@
 #include <boost/thread/detail/config.hpp>

 #include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread_time.hpp>
 #include <boost/thread/condition.hpp>
@@ -97,86 +96,6 @@ struct test_trylock
    }
 };

-template<typename Mutex>
-struct test_lock_times_out_if_other_thread_has_lock
-{
-    typedef boost::unique_lock<Mutex> Lock;
-    
-    Mutex m;
-    boost::mutex done_mutex;
-    bool done;
-    bool locked;
-    boost::condition_variable done_cond;
-    
-    test_lock_times_out_if_other_thread_has_lock():
-        done(false),locked(false)
-    {}
-
-    void locking_thread()
-    {
-        Lock lock(m,boost::defer_lock);
-        lock.timed_lock(boost::posix_time::milliseconds(50));
-
-        boost::lock_guard<boost::mutex> lk(done_mutex);
-        locked=lock.owns_lock();
-        done=true;
-        done_cond.notify_one();
-    }
-
-    void locking_thread_through_constructor()
-    {
-        Lock lock(m,boost::posix_time::milliseconds(50));
-
-        boost::lock_guard<boost::mutex> lk(done_mutex);
-        locked=lock.owns_lock();
-        done=true;
-        done_cond.notify_one();
-    }
-
-    bool is_done() const
-    {
-        return done;
-    }
-
-    typedef test_lock_times_out_if_other_thread_has_lock<Mutex> this_type;
-    
-    void do_test(void (this_type::*test_func)())
-    {
-        Lock lock(m);
-
-        locked=false;
-        done=false;
-        
-        boost::thread t(test_func,this);
-
-        try
-        {
-            {
-                boost::mutex::scoped_lock lk(done_mutex);
-                BOOST_CHECK(done_cond.timed_wait(lk,boost::posix_time::seconds(2),
-                                                 boost::bind(&this_type::is_done,this)));
-                BOOST_CHECK(!locked);
-            }
-            
-            lock.unlock();
-            t.join();
-        }
-        catch(...)
-        {
-            lock.unlock();
-            t.join();
-            throw;
-        }
-    }
-    
-
-    void operator()()
-    {
-        do_test(&this_type::locking_thread);
-        do_test(&this_type::locking_thread_through_constructor);
-    }
-};
-
 template <typename M>
 struct test_timedlock
 {
@@ -190,8 +109,6 @@ struct test_timedlock

    void operator()()
    {
-        test_lock_times_out_if_other_thread_has_lock<mutex_type>()();
-        
        mutex_type mutex;
        boost::condition condition;

@@ -261,7 +178,6 @@ struct test_recursive_lock
    }
 };

-
 void do_test_mutex()
 {
    test_lock<boost::mutex>()();
--- a/test/test_shared_mutex.cpp
+++ b/test/test_shared_mutex.cpp
@@ -17,7 +17,7 @@

 void test_multiple_readers()
 {
-    unsigned const number_of_threads=10;
+    unsigned const number_of_threads=100;
    
    boost::thread_group pool;

@@ -64,7 +64,7 @@ void test_multiple_readers()

 void test_only_one_writer_permitted()
 {
-    unsigned const number_of_threads=10;
+    unsigned const number_of_threads=100;
    
    boost::thread_group pool;

@@ -164,7 +164,7 @@ void test_unlocking_writer_unblocks_all_readers()
    boost::mutex finish_mutex;
    boost::mutex::scoped_lock finish_lock(finish_mutex);

-    unsigned const reader_count=10;
+    unsigned const reader_count=100;

    try
    {
@@ -218,8 +218,8 @@ void test_unlocking_last_reader_only_unblocks_one_writer()
    boost::mutex finish_writing_mutex;
    boost::mutex::scoped_lock finish_writing_lock(finish_writing_mutex);

-    unsigned const reader_count=10;
-    unsigned const writer_count=10;
+    unsigned const reader_count=100;
+    unsigned const writer_count=100;

    try
    {
--- a/test/test_shared_mutex_part_2.cpp
+++ b/test/test_shared_mutex_part_2.cpp
@@ -15,41 +15,10 @@
        BOOST_CHECK_EQUAL(value,expected_value);                     \
    }

-class simple_upgrade_thread
-{
-    boost::shared_mutex& rwm;
-    boost::mutex& finish_mutex;
-    boost::mutex& unblocked_mutex;
-    unsigned& unblocked_count;
-        
-    void operator=(simple_upgrade_thread&);
-        
-public:
-    simple_upgrade_thread(boost::shared_mutex& rwm_,
-                          boost::mutex& finish_mutex_,
-                          boost::mutex& unblocked_mutex_,
-                          unsigned& unblocked_count_):
-        rwm(rwm_),finish_mutex(finish_mutex_),
-        unblocked_mutex(unblocked_mutex_),unblocked_count(unblocked_count_)
-    {}
-        
-    void operator()()
-    {
-        boost::upgrade_lock<boost::shared_mutex> lk(rwm);
-            
-        {
-            boost::mutex::scoped_lock ulk(unblocked_mutex);
-            ++unblocked_count;
-        }
-            
-        boost::mutex::scoped_lock flk(finish_mutex);
-    }
-};
-

 void test_only_one_upgrade_lock_permitted()
 {
-    unsigned const number_of_threads=10;
+    unsigned const number_of_threads=100;
    
    boost::thread_group pool;

@@ -102,7 +71,7 @@ void test_can_lock_upgrade_if_currently_locked_shared()
    boost::mutex finish_mutex;
    boost::mutex::scoped_lock finish_lock(finish_mutex);

-    unsigned const reader_count=10;
+    unsigned const reader_count=100;

    try
    {
@@ -161,29 +130,6 @@ void test_if_other_thread_has_write_lock_try_lock_shared_returns_false()
    writer.join();
 }

-void test_if_other_thread_has_write_lock_try_lock_upgrade_returns_false()
-{
-
-    boost::shared_mutex rw_mutex;
-    boost::mutex finish_mutex;
-    boost::mutex unblocked_mutex;
-    unsigned unblocked_count=0;
-    boost::mutex::scoped_lock finish_lock(finish_mutex);
-    boost::thread writer(simple_writing_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
-    boost::this_thread::sleep(boost::posix_time::seconds(1));
-    CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
-
-    bool const try_succeeded=rw_mutex.try_lock_upgrade();
-    BOOST_CHECK(!try_succeeded);
-    if(try_succeeded)
-    {
-        rw_mutex.unlock_upgrade();
-    }
-
-    finish_lock.unlock();
-    writer.join();
-}
-
 void test_if_no_thread_has_lock_try_lock_shared_returns_true()
 {
    boost::shared_mutex rw_mutex;
@@ -195,17 +141,6 @@ void test_if_no_thread_has_lock_try_lock_shared_returns_true()
    }
 }

-void test_if_no_thread_has_lock_try_lock_upgrade_returns_true()
-{
-    boost::shared_mutex rw_mutex;
-    bool const try_succeeded=rw_mutex.try_lock_upgrade();
-    BOOST_CHECK(try_succeeded);
-    if(try_succeeded)
-    {
-        rw_mutex.unlock_upgrade();
-    }
-}
-
 void test_if_other_thread_has_shared_lock_try_lock_shared_returns_true()
 {

@@ -229,52 +164,6 @@ void test_if_other_thread_has_shared_lock_try_lock_shared_returns_true()
    writer.join();
 }

-void test_if_other_thread_has_shared_lock_try_lock_upgrade_returns_true()
-{
-
-    boost::shared_mutex rw_mutex;
-    boost::mutex finish_mutex;
-    boost::mutex unblocked_mutex;
-    unsigned unblocked_count=0;
-    boost::mutex::scoped_lock finish_lock(finish_mutex);
-    boost::thread writer(simple_reading_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
-    boost::thread::sleep(delay(1));
-    CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
-
-    bool const try_succeeded=rw_mutex.try_lock_upgrade();
-    BOOST_CHECK(try_succeeded);
-    if(try_succeeded)
-    {
-        rw_mutex.unlock_upgrade();
-    }
-
-    finish_lock.unlock();
-    writer.join();
-}
-
-void test_if_other_thread_has_upgrade_lock_try_lock_upgrade_returns_false()
-{
-
-    boost::shared_mutex rw_mutex;
-    boost::mutex finish_mutex;
-    boost::mutex unblocked_mutex;
-    unsigned unblocked_count=0;
-    boost::mutex::scoped_lock finish_lock(finish_mutex);
-    boost::thread writer(simple_upgrade_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
-    boost::this_thread::sleep(boost::posix_time::seconds(1));
-    CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
-
-    bool const try_succeeded=rw_mutex.try_lock_upgrade();
-    BOOST_CHECK(!try_succeeded);
-    if(try_succeeded)
-    {
-        rw_mutex.unlock_upgrade();
-    }
-
-    finish_lock.unlock();
-    writer.join();
-}
-
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
    boost::unit_test_framework::test_suite* test =
--- a/test/test_thread_mf.cpp
+++ b/test/test_thread_mf.cpp
@@ -45,90 +45,92 @@ struct X

 int main()
 {
+    using namespace boost;
+
    X x;

    // 0

-    boost::thread( &X::f0, &x ).join();
-    boost::thread( &X::f0, boost::ref(x) ).join();
+    thread( &X::f0, &x ).join();
+    thread( &X::f0, ref(x) ).join();

-    boost::thread( &X::g0, &x ).join();
-    boost::thread( &X::g0, x ).join();
-    boost::thread( &X::g0, boost::ref(x) ).join();
+    thread( &X::g0, &x ).join();
+    thread( &X::g0, x ).join();
+    thread( &X::g0, ref(x) ).join();

    // 1

-    boost::thread( &X::f1, &x, 1 ).join();
-    boost::thread( &X::f1, boost::ref(x), 1 ).join();
+    thread( &X::f1, &x, 1 ).join();
+    thread( &X::f1, ref(x), 1 ).join();

-    boost::thread( &X::g1, &x, 1 ).join();
-    boost::thread( &X::g1, x, 1 ).join();
-    boost::thread( &X::g1, boost::ref(x), 1 ).join();
+    thread( &X::g1, &x, 1 ).join();
+    thread( &X::g1, x, 1 ).join();
+    thread( &X::g1, ref(x), 1 ).join();

    // 2

-    boost::thread( &X::f2, &x, 1, 2 ).join();
-    boost::thread( &X::f2, boost::ref(x), 1, 2 ).join();
+    thread( &X::f2, &x, 1, 2 ).join();
+    thread( &X::f2, ref(x), 1, 2 ).join();

-    boost::thread( &X::g2, &x, 1, 2 ).join();
-    boost::thread( &X::g2, x, 1, 2 ).join();
-    boost::thread( &X::g2, boost::ref(x), 1, 2 ).join();
+    thread( &X::g2, &x, 1, 2 ).join();
+    thread( &X::g2, x, 1, 2 ).join();
+    thread( &X::g2, ref(x), 1, 2 ).join();

    // 3

-    boost::thread( &X::f3, &x, 1, 2, 3 ).join();
-    boost::thread( &X::f3, boost::ref(x), 1, 2, 3 ).join();
+    thread( &X::f3, &x, 1, 2, 3 ).join();
+    thread( &X::f3, ref(x), 1, 2, 3 ).join();

-    boost::thread( &X::g3, &x, 1, 2, 3 ).join();
-    boost::thread( &X::g3, x, 1, 2, 3 ).join();
-    boost::thread( &X::g3, boost::ref(x), 1, 2, 3 ).join();
+    thread( &X::g3, &x, 1, 2, 3 ).join();
+    thread( &X::g3, x, 1, 2, 3 ).join();
+    thread( &X::g3, ref(x), 1, 2, 3 ).join();

    // 4

-    boost::thread( &X::f4, &x, 1, 2, 3, 4 ).join();
-    boost::thread( &X::f4, boost::ref(x), 1, 2, 3, 4 ).join();
+    thread( &X::f4, &x, 1, 2, 3, 4 ).join();
+    thread( &X::f4, ref(x), 1, 2, 3, 4 ).join();

-    boost::thread( &X::g4, &x, 1, 2, 3, 4 ).join();
-    boost::thread( &X::g4, x, 1, 2, 3, 4 ).join();
-    boost::thread( &X::g4, boost::ref(x), 1, 2, 3, 4 ).join();
+    thread( &X::g4, &x, 1, 2, 3, 4 ).join();
+    thread( &X::g4, x, 1, 2, 3, 4 ).join();
+    thread( &X::g4, ref(x), 1, 2, 3, 4 ).join();

    // 5

-    boost::thread( &X::f5, &x, 1, 2, 3, 4, 5 ).join();
-    boost::thread( &X::f5, boost::ref(x), 1, 2, 3, 4, 5 ).join();
+    thread( &X::f5, &x, 1, 2, 3, 4, 5 ).join();
+    thread( &X::f5, ref(x), 1, 2, 3, 4, 5 ).join();

-    boost::thread( &X::g5, &x, 1, 2, 3, 4, 5 ).join();
-    boost::thread( &X::g5, x, 1, 2, 3, 4, 5 ).join();
-    boost::thread( &X::g5, boost::ref(x), 1, 2, 3, 4, 5 ).join();
+    thread( &X::g5, &x, 1, 2, 3, 4, 5 ).join();
+    thread( &X::g5, x, 1, 2, 3, 4, 5 ).join();
+    thread( &X::g5, ref(x), 1, 2, 3, 4, 5 ).join();

    // 6

-    boost::thread( &X::f6, &x, 1, 2, 3, 4, 5, 6 ).join();
-    boost::thread( &X::f6, boost::ref(x), 1, 2, 3, 4, 5, 6 ).join();
+    thread( &X::f6, &x, 1, 2, 3, 4, 5, 6 ).join();
+    thread( &X::f6, ref(x), 1, 2, 3, 4, 5, 6 ).join();

-    boost::thread( &X::g6, &x, 1, 2, 3, 4, 5, 6 ).join();
-    boost::thread( &X::g6, x, 1, 2, 3, 4, 5, 6 ).join();
-    boost::thread( &X::g6, boost::ref(x), 1, 2, 3, 4, 5, 6 ).join();
+    thread( &X::g6, &x, 1, 2, 3, 4, 5, 6 ).join();
+    thread( &X::g6, x, 1, 2, 3, 4, 5, 6 ).join();
+    thread( &X::g6, ref(x), 1, 2, 3, 4, 5, 6 ).join();

    // 7

-    boost::thread( &X::f7, &x, 1, 2, 3, 4, 5, 6, 7).join();
-    boost::thread( &X::f7, boost::ref(x), 1, 2, 3, 4, 5, 6, 7).join();
+    thread( &X::f7, &x, 1, 2, 3, 4, 5, 6, 7).join();
+    thread( &X::f7, ref(x), 1, 2, 3, 4, 5, 6, 7).join();

-    boost::thread( &X::g7, &x, 1, 2, 3, 4, 5, 6, 7).join();
-    boost::thread( &X::g7, x, 1, 2, 3, 4, 5, 6, 7).join();
-    boost::thread( &X::g7, boost::ref(x), 1, 2, 3, 4, 5, 6, 7).join();
+    thread( &X::g7, &x, 1, 2, 3, 4, 5, 6, 7).join();
+    thread( &X::g7, x, 1, 2, 3, 4, 5, 6, 7).join();
+    thread( &X::g7, ref(x), 1, 2, 3, 4, 5, 6, 7).join();

    // 8

-    boost::thread( &X::f8, &x, 1, 2, 3, 4, 5, 6, 7, 8 ).join();
-    boost::thread( &X::f8, boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8 ).join();
+    thread( &X::f8, &x, 1, 2, 3, 4, 5, 6, 7, 8 ).join();
+    thread( &X::f8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8 ).join();

-    boost::thread( &X::g8, &x, 1, 2, 3, 4, 5, 6, 7, 8 ).join();
-    boost::thread( &X::g8, x, 1, 2, 3, 4, 5, 6, 7, 8 ).join();
-    boost::thread( &X::g8, boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8 ).join();
+    thread( &X::g8, &x, 1, 2, 3, 4, 5, 6, 7, 8 ).join();
+    thread( &X::g8, x, 1, 2, 3, 4, 5, 6, 7, 8 ).join();
+    thread( &X::g8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8 ).join();

    BOOST_TEST( x.hash == 23558 );

-    return boost::report_errors();
+    return report_errors();
 }
--- a/test/test_thread_move.cpp
+++ b/test/test_thread_move.cpp
@@ -5,59 +5,26 @@
 #include <boost/thread/thread.hpp>
 #include <boost/test/unit_test.hpp>

-void do_nothing(boost::thread::id* my_id)
-{
-    *my_id=boost::this_thread::get_id();
-}
+void do_nothing()
+{}

 void test_move_on_construction()
 {
-    boost::thread::id the_id;
-    boost::thread x=boost::thread(do_nothing,&the_id);
-    boost::thread::id x_id=x.get_id();
+    boost::thread x=boost::thread(do_nothing);
    x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
 }

-boost::thread make_thread(boost::thread::id* the_id)
+boost::thread make_thread()
 {
-    return boost::thread(do_nothing,the_id);
+    return boost::thread(do_nothing);
 }

 void test_move_from_function_return()
 {
-    boost::thread::id the_id;
-    boost::thread x=make_thread(&the_id);
-    boost::thread::id x_id=x.get_id();
+    boost::thread x=make_thread();
    x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
 }

-boost::thread make_thread_return_lvalue(boost::thread::id* the_id)
-{
-    boost::thread t(do_nothing,the_id);
-    return boost::move(t);
-}
-
-void test_move_from_function_return_lvalue()
-{
-    boost::thread::id the_id;
-    boost::thread x=make_thread_return_lvalue(&the_id);
-    boost::thread::id x_id=x.get_id();
-    x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
-}
-
-void test_move_assign()
-{
-    boost::thread::id the_id;
-    boost::thread x(do_nothing,&the_id);
-    boost::thread y;
-    y=boost::move(x);
-    boost::thread::id y_id=y.get_id();
-    y.join();
-    BOOST_CHECK_EQUAL(the_id,y_id);
-}

 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
@@ -66,7 +33,5 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])

    test->add(BOOST_TEST_CASE(test_move_on_construction));
    test->add(BOOST_TEST_CASE(test_move_from_function_return));
-    test->add(BOOST_TEST_CASE(test_move_from_function_return_lvalue));
-    test->add(BOOST_TEST_CASE(test_move_assign));
    return test;
 }
--- a/test/test_xtime.cpp
+++ b/test/test_xtime.cpp
@@ -1,6 +1,5 @@
 // Copyright (C) 2001-2003
 // William E. Kempf
-// Copyright (C) 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)
@@ -10,8 +9,6 @@
 #include <boost/thread/xtime.hpp>

 #include <boost/test/unit_test.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition.hpp>

 void test_xtime_cmp()
 {
@@ -56,45 +53,6 @@ void test_xtime_get()
    }
 }

-void test_xtime_mutex_backwards_compatibility()
-{
-    boost::timed_mutex m;
-    BOOST_CHECK(m.timed_lock(boost::get_xtime(boost::get_system_time()+boost::posix_time::milliseconds(10))));
-    m.unlock();
-    boost::timed_mutex::scoped_timed_lock lk(m,boost::get_xtime(boost::get_system_time()+boost::posix_time::milliseconds(10)));
-    BOOST_CHECK(lk.owns_lock());
-    if(lk.owns_lock())
-    {
-        lk.unlock();
-    }
-    BOOST_CHECK(lk.timed_lock(boost::get_xtime(boost::get_system_time()+boost::posix_time::milliseconds(10))));
-    if(lk.owns_lock())
-    {
-        lk.unlock();
-    }
-}
-
-bool predicate()
-{
-    return false;
-}
-
-
-void test_xtime_condvar_backwards_compatibility()
-{
-    boost::condition_variable cond;
-    boost::condition_variable_any cond_any;
-    boost::mutex m;
-    
-    boost::mutex::scoped_lock lk(m);
-    cond.timed_wait(lk,boost::get_xtime(boost::get_system_time()+boost::posix_time::milliseconds(10)));
-    cond.timed_wait(lk,boost::get_xtime(boost::get_system_time()+boost::posix_time::milliseconds(10)),predicate);
-    cond_any.timed_wait(lk,boost::get_xtime(boost::get_system_time()+boost::posix_time::milliseconds(10)));
-    cond_any.timed_wait(lk,boost::get_xtime(boost::get_system_time()+boost::posix_time::milliseconds(10)),predicate);
-}
-
-
-
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
    boost::unit_test_framework::test_suite* test =
@@ -102,8 +60,6 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])

    test->add(BOOST_TEST_CASE(&test_xtime_cmp));
    test->add(BOOST_TEST_CASE(&test_xtime_get));
-    test->add(BOOST_TEST_CASE(&test_xtime_mutex_backwards_compatibility));
-    test->add(BOOST_TEST_CASE(&test_xtime_condvar_backwards_compatibility));

    return test;
 }
Author	SHA1	Message	Date
Beman Dawes	c484c376d3	Branch at revision 46530 [SVN r46531]	2008-06-19 18:57:10 +00:00
Anthony Williams	851d6a987f	Correctly remove the reference type when copying the thread function into the thread data area so we don't end up with a dangling reference [SVN r46295]	2008-06-10 15:29:35 +00:00
Anthony Williams	9bebd7b35f	Disable general templated thread constructor for movable types, in order to prevent it trying to act as a thread copy constructor for EDG based compilers [SVN r46273]	2008-06-09 14:00:03 +00:00
Anthony Williams	309acb9597	Don't try and use _interlockedbittestandset primitives if we don't know they're present [SVN r46219]	2008-06-07 20:54:19 +00:00
Anthony Williams	a56887167e	Added swap for try_lock_wrapper [SVN r46164]	2008-06-05 12:25:58 +00:00
Anthony Williams	e984dff4e4	Combined TSS header for pthread and win32, #1958 now fixed for pthread too [SVN r46162]	2008-06-05 11:19:06 +00:00
Anthony Williams	685e4d446b	Test and fix for bug #1958 on Win32 [SVN r46161]	2008-06-05 11:16:05 +00:00
Anthony Williams	8af680f307	Added swap for unique_lock [SVN r46160]	2008-06-05 10:39:08 +00:00
Anthony Williams	6c60cce60d	Removed partial initializer for res: both values will be assigned later, so no need to initialize either [SVN r46124]	2008-06-04 16:05:29 +00:00
Anthony Williams	5882a675bb	Added extra initializer to timeout to try and eliminate warnings with some compilers [SVN r46123]	2008-06-04 16:03:51 +00:00
Anthony Williams	a5e95845b3	Added documentation for swap() [SVN r46122]	2008-06-04 16:00:13 +00:00
Anthony Williams	5b83d81e40	Added free function swap() for threads [SVN r46121]	2008-06-04 15:50:34 +00:00
Anthony Williams	c8e5ad564d	basic_condition_variable::lock_entry extracted to basic_cv_lock_entry in order to try and eliminate problems on Borland compiler [SVN r46094]	2008-06-03 20:56:39 +00:00
Anthony Williams	5edfa273ff	removed unused header [SVN r46093]	2008-06-03 20:55:40 +00:00
Anthony Williams	4db57bcb10	Move thread_data to detail namespace rather than have it as a nested type of boost::thread, to try and help compilers that have problems with the partial specializations for reference_wrapper [SVN r45912]	2008-05-29 15:38:08 +00:00
Anthony Williams	3f13340903	Don't construct function objects directly in boost::thread constructor as some compilers can't handle that. [SVN r45911]	2008-05-29 15:36:52 +00:00
Anthony Williams	6abb53c9d3	Move definition of constructor and destructor of condition_variable into condition_variable_fwd.hpp, so they are always available [SVN r45909]	2008-05-29 15:16:55 +00:00
Anthony Williams	fdd20a519e	Use wrapper functions in try_lock_wrapper rather than using declarations, as the latter confuse some compilers [SVN r45908]	2008-05-29 15:16:04 +00:00
Anthony Williams	67cc49f333	More tests for generic locks, and a new range version [SVN r45897]	2008-05-29 09:02:05 +00:00
Anthony Williams	31a34cd0b5	Added missing "no" [SVN r45870]	2008-05-28 14:50:25 +00:00
Anthony Williams	ef8c08ba99	Removed surplus "the" [SVN r45869]	2008-05-28 12:55:30 +00:00
Anthony Williams	2991ca6c6f	Added abi prefix and suffix headers [SVN r45865]	2008-05-28 11:02:06 +00:00
Anthony Williams	52bace18b2	hardware_concurrency works for CYGWIN [SVN r45860]	2008-05-28 09:38:14 +00:00
Anthony Williams	767d14ae4f	Added documentation for time support in the thread library [SVN r45859]	2008-05-28 09:00:32 +00:00
Anthony Williams	1a5c911e36	Added documentation for time support in the thread library [SVN r45858]	2008-05-28 09:00:23 +00:00
Anthony Williams	6e42a04e43	Added note about move support [SVN r45856]	2008-05-28 08:09:07 +00:00
Anthony Williams	28be2cfeef	intrusive_ptr_add_ref and intrusive_ptr_release need to be inline if defined in the header [SVN r45809]	2008-05-27 06:32:05 +00:00
Anthony Williams	8be168fd87	Basic tests for lock() when other thread is acquiring locks in same or opposite order [SVN r45767]	2008-05-26 08:59:48 +00:00
Anthony Williams	eee95fef57	Initial test for generic lock functions [SVN r45766]	2008-05-26 08:40:21 +00:00
Anthony Williams	9ea179b052	Initial test for generic lock functions [SVN r45765]	2008-05-26 08:40:13 +00:00
Anthony Williams	6868280409	Try and avoid compile errors in test_thread_callable_object_one_argument [SVN r45764]	2008-05-26 07:36:16 +00:00
Anthony Williams	e00b764454	The signature of _interlockedbittestandset changes between MSVC 2005 and MSVC 2008 [SVN r45689]	2008-05-23 19:53:06 +00:00
Anthony Williams	999613c686	Added note about mutex not being recursive [SVN r45688]	2008-05-23 19:33:18 +00:00
Anthony Williams	c2661d7eb5	define intrusive_ptr_add_ref and intrusive_ptr_release at namespace scope rather than inline as friends in order to try and avoid compiler problems [SVN r45682]	2008-05-23 15:18:19 +00:00
Anthony Williams	4d21dd1f47	try_lock_wrapper implements operator! in order to try and avoid compiler problems [SVN r45681]	2008-05-23 15:17:14 +00:00
Anthony Williams	a0a0e57527	Fixed #ifdef to actually use BTS primitives on MSVC 9 [SVN r45676]	2008-05-23 13:16:01 +00:00
Anthony Williams	d8af0d0b4e	Reset thread_info on move rather than assigning 0 [SVN r45672]	2008-05-23 10:48:07 +00:00
Anthony Williams	113288e3b0	tidying up move [SVN r45661]	2008-05-22 16:33:34 +00:00
Anthony Williams	afecfd7c2d	Refactored boost::thread code to try and remove duplication [SVN r45647]	2008-05-22 11:49:48 +00:00
Anthony Williams	94d89aac5f	more rvalue reference stuff [SVN r45626]	2008-05-21 21:11:30 +00:00
Anthony Williams	8831b13efc	Use lock_guard<> instead of unique_lock<> internally. Clear out generations after notify_all, as they're all notified [SVN r45625]	2008-05-21 21:10:45 +00:00
Peter Dimov	01f99da03a	Extended boost::thread to 9 arguments, hopefully fixed member function ambiguity. [SVN r45621]	2008-05-21 20:44:08 +00:00
Anthony Williams	080654e3ef	New tests for a normal function with one argument, and a member function with 0 or 1 arguments [SVN r45607]	2008-05-21 13:38:04 +00:00
Anthony Williams	2ac2eb2a61	try_lock_wrapper has its own operator bool_type to avoid problems with a using declaration [SVN r45602]	2008-05-21 10:39:47 +00:00
Anthony Williams	61b940b705	Renamed namespace user to user_test_ns to try and avoid a name clash on some platforms [SVN r45601]	2008-05-21 09:51:53 +00:00
Anthony Williams	4a4f87e017	support for a generic lock() function [SVN r45481]	2008-05-18 09:10:20 +00:00
Anthony Williams	6d5e7f63a7	Added beginnings of real rvalue-reference support [SVN r45479]	2008-05-18 08:45:44 +00:00
Anthony Williams	f77285f375	Updated docs to make it explicit that terminate is called if a thread function throws an exception [SVN r45294]	2008-05-12 09:04:02 +00:00
Anthony Williams	dc5d03a6dc	Cleaned up to remove warnings [SVN r45244]	2008-05-09 07:59:57 +00:00
Anthony Williams	ea0961b7f6	Fixed type truncation warning [SVN r45243]	2008-05-09 07:49:22 +00:00
Anthony Williams	33d9f9774c	Test and fix for bug #1905 [SVN r45242]	2008-05-09 07:48:44 +00:00
Anthony Williams	86097fa038	Use _WIN32 rather than WIN32 to prevent include of <unistd.h> [SVN r45241]	2008-05-09 07:47:14 +00:00
Anthony Williams	70d9dbc45a	Added default constructor to lock types [SVN r45212]	2008-05-08 14:34:40 +00:00
Anthony Williams	3926fd3a20	Added docs for native_handle [SVN r45211]	2008-05-08 12:59:59 +00:00
Anthony Williams	7861cf1146	Added native_handle to mutex types where possible [SVN r45210]	2008-05-08 12:59:10 +00:00
Anthony Williams	0516b86a6e	new BTS-based mutex implementation on win32 [SVN r45119]	2008-05-04 22:39:52 +00:00
Anthony Williams	ec735d3e9b	Simplified move support [SVN r45108]	2008-05-04 09:52:54 +00:00
Anthony Williams	1c5c070983	Updated locks.hpp to work with gcc as well as msvc [SVN r44846]	2008-04-28 12:26:27 +00:00
Anthony Williams	a5c02b73dc	Added entry to breaking changes about default-constructed threads and the current thread: issue #1835 [SVN r44840]	2008-04-28 09:10:38 +00:00
Anthony Williams	918b920670	Added detail::try_lock_wrapper for use as scoped_try_lock typedefs, to fix issue #1873 [SVN r44838]	2008-04-28 09:00:58 +00:00
Anthony Williams	de67d2e27e	Fixed g++ compile error [SVN r44773]	2008-04-26 07:34:46 +00:00
Anthony Williams	bc89df04cb	Revamped condition variable to try and fix swallowed-notify problems (trac issue #1834 ) [SVN r44699]	2008-04-21 16:22:16 +00:00
Anthony Williams	c26a4cf082	added private copy assignment operator and copy constructor to remove warnings [SVN r44698]	2008-04-21 16:20:31 +00:00
Anthony Williams	6e1a866b13	Fix for issue #1657 [SVN r44424]	2008-04-14 21:04:33 +00:00
Anthony Williams	f91986ad0d	Added extended adopt/defer/try constructors to upgrade_lock [SVN r44370]	2008-04-13 15:50:08 +00:00
Anthony Williams	795cc23f3e	Added test and fix for win32 condition_variable broadcast bug similar to #1803 [SVN r44168]	2008-04-11 08:52:09 +00:00
Anthony Williams	a3695bd4a0	Updated thread.hpp as catch-all header [SVN r44153]	2008-04-10 18:34:42 +00:00
Anthony Williams	08dc521daf	Added native_handle to condition_variable on pthreads [SVN r44152]	2008-04-10 15:52:01 +00:00
Anthony Williams	8b916d21b1	added tests for plain timed_lock on shared_mutex [SVN r44150]	2008-04-10 14:15:26 +00:00
Anthony Williams	c40f47a78a	added overloads of timed_lock_shared with a relative timeout to shared_mutex [SVN r44149]	2008-04-10 14:07:39 +00:00
Anthony Williams	e9fb470b06	Added native_handle to thread on posix platforms [SVN r44148]	2008-04-10 13:35:07 +00:00
Anthony Williams	343d049772	fix for trac ticket #1804 [SVN r44147]	2008-04-10 13:27:44 +00:00
Anthony Williams	86f9480da4	fix for notify problem in trac ticket #1803 [SVN r44146]	2008-04-10 13:14:43 +00:00
Anthony Williams	8696b610ca	Added test for trac ticket #1803 : condition_variable::notify_one may fail to wake a waiting thread on win32 [SVN r44136]	2008-04-09 19:33:06 +00:00
Anthony Williams	6f13227eda	Added locked-> owns_lock change to breaking changes [SVN r44089]	2008-04-07 13:09:36 +00:00
Anthony Williams	58d5110e61	removed forward declaration for undefined type exclusive_lock [SVN r43847]	2008-03-24 21:44:36 +00:00
Anthony Williams	76e53c7bc5	Removed some warnings: those from issue #1640 and others [SVN r43730]	2008-03-19 17:25:13 +00:00
Anthony Williams	cfb08be1a8	New documentation for new thread library [SVN r43671]	2008-03-17 10:29:27 +00:00
Anthony Williams	b5bbb7fb1c	Test and fix for bug #1693 to ensure thread_specific_ptr works as desired [SVN r43666]	2008-03-17 08:36:09 +00:00
Anthony Williams	a76c33f8cc	made the callable_no_args function object a named object rather than a temporary, in order to avoid gratuitous breakage on some compilers [SVN r43528]	2008-03-06 07:59:16 +00:00
Anthony Williams	810306b8f3	thread constructor now accepts up to three additional arguments to pass to thread function [SVN r43464]	2008-03-03 10:52:44 +00:00
Anthony Williams	6c22bdb3bd	Test and fix for issue #1665 [SVN r43461]	2008-03-03 08:44:42 +00:00
Daniel James	6a0d3e98bc	Fix broken copyright urls. Fixes #1573 . [SVN r43422]	2008-02-27 18:51:14 +00:00
Anthony Williams	3809321037	added test for duration overloads of timed_lock, and added missing implementation to win32 version [SVN r43094]	2008-02-04 13:16:32 +00:00
Anthony Williams	eef695bdf0	Provide tss_cleanup_implemented as a dummy function on Windows CE to allow tests to run [SVN r42818]	2008-01-16 15:23:36 +00:00
Anthony Williams	ab01ab1e4d	removed references to NULL [SVN r42657]	2008-01-10 14:19:36 +00:00
Anthony Williams	c8d8a108a7	Updated thread ID test [SVN r42228]	2007-12-21 10:54:59 +00:00
Anthony Williams	7afd9efcc5	added hardware_concurrency support for apple, freebsd and sun platforms [SVN r42195]	2007-12-20 08:37:02 +00:00
Anthony Williams	56ded87ad2	added missing parentheses [SVN r42194]	2007-12-20 07:46:00 +00:00
Anthony Williams	82e503339b	Implement hardware_concurrency for pthread [SVN r42168]	2007-12-19 10:45:01 +00:00
Anthony Williams	713d0c7ace	Updated thread ID, and added tests [SVN r42166]	2007-12-19 10:39:45 +00:00
Anthony Williams	25ad6e3f8f	boost::move support for locks [SVN r42118]	2007-12-17 12:52:50 +00:00
Anthony Williams	df0197b617	Updated move function test to be fair to Borland [SVN r42117]	2007-12-17 11:24:13 +00:00
Anthony Williams	a89c4f01ad	explicit move functions for threads, with a test [SVN r42087]	2007-12-15 22:36:43 +00:00
Anthony Williams	ae67099633	added timed_wait overloads that take a duration [SVN r42086]	2007-12-15 22:34:30 +00:00
Anthony Williams	57542d3a5c	fixed order of comparison in timeout check [SVN r41819]	2007-12-07 08:11:11 +00:00
Anthony Williams	9a1da14116	improved timeout checks [SVN r41741]	2007-12-05 10:58:45 +00:00
Anthony Williams	ed050d753d	added missing include of detail/config.hpp [SVN r41738]	2007-12-05 08:27:44 +00:00
Anthony Williams	8bec363710	changed order of declaration to eliminate warnings [SVN r41687]	2007-12-04 14:07:01 +00:00
Anthony Williams	7c68e190a9	Added test for thread move constructor; implemented move on pthreads [SVN r41686]	2007-12-04 13:02:58 +00:00
Anthony Williams	7ebf5ea3d1	add explicit casts to remove warnings [SVN r41684]	2007-12-04 12:08:38 +00:00
Anthony Williams	11e0435a4b	don't dllexport/dllimport inline functions [SVN r41683]	2007-12-04 11:44:25 +00:00
Anthony Williams	d15ee57cd1	split shared mutex tests in two to take less time [SVN r41682]	2007-12-04 10:04:30 +00:00
Anthony Williams	56d660b7fd	changed boost::move to boost::detail::thread_move to fix issue #1492 [SVN r41681]	2007-12-04 09:15:37 +00:00
Anthony Williams	792958e693	fixed typo in condition_variable_any::timed_wait [SVN r41679]	2007-12-04 07:57:23 +00:00
Anthony Williams	914e67dc04	check predicate before returning if we time out on a predicated version of timed_wait [SVN r41668]	2007-12-03 22:00:26 +00:00
Anthony Williams	b50a7ccb61	interruptible_wait (and hence condition timed_wait) now uses a WaitableTimer where possible, to be robust in the face of clock changes [SVN r41505]	2007-11-30 18:38:21 +00:00
Anthony Williams	f827709d42	add support for relative timeouts to condition timed_wait [SVN r41413]	2007-11-27 14:24:29 +00:00
Anthony Williams	36abb42175	reverted accidental checkin of new timed_wait functions on condition_variable [SVN r41405]	2007-11-26 21:15:04 +00:00
Anthony Williams	40f3b1b4c8	once_flag uses zero-initialization on POSIX as well as windows [SVN r41401]	2007-11-26 17:01:08 +00:00
Anthony Williams	4f35e25688	fixed import/export declarations so new once code works with pthread-win32 [SVN r41398]	2007-11-26 15:44:07 +00:00
Anthony Williams	270e88edd7	Don't compare native_handle_t against 0 --- do appropriate checks in create_native_thread for platforms where pthread_t is not comparable [SVN r41396]	2007-11-26 13:29:15 +00:00
Anthony Williams	5ded171247	workaround for Borland compiler [SVN r41395]	2007-11-26 12:17:45 +00:00
				`@@ -1 +0,0 @@`
				`boost_module(thread DEPENDS date_time bind optional range)`