Release 1.48.0

[SVN r75495]

build/Jamfile.v2

@@ -0,0 +1,207 @@
+# $Id$
+# Copyright 2006-2007 Roland Schwarz.
+# Copyright 2007 Anthony Williams
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+#########################################################################
+# The boost threading library can be built on top of different API's
+# Currently this is the win32 API and the pthreads API.
+# Pthread is native on unix variants.
+# To get pthread on windows you need the pthread win32 library
+# http://sourceware.org/pthreads-win32 which is available under LGPL.
+#
+# You need to provide the include path and lib path in the variables
+# PTW32_INCLUDE and PTW32_LIB respectively. You can specify these
+# paths in site-config.jam, user-config.jam or in the environment.
+# A new feature is provided to request a specific API:
+# <threadapi>win32 and <threadapi)pthread.
+#
+# The naming of the resulting libraries is mostly the same for the
+# variant native to the build platform, i.e.
+# boost_thread and the boost specific tagging.
+# For the library variant that is not native on the build platform
+# an additional tag is applied:
+# boost_thread_pthread for the pthread variant on windows, and
+# boost_thread_win32 for the win32 variant (likely when built on cygwin).
+#
+# To request the pthread variant on windows, from boost root you would
+# say e.g:
+# bjam msvc-8.0 --with-thread install threadapi=pthread
+#########################################################################
+
+import os ;
+import feature ;
+import indirect ;
+import path ;
+
+project boost/thread
+    : source-location ../src
+    : requirements <threading>multi
+      <link>static:<define>BOOST_THREAD_BUILD_LIB=1
+      <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
+      -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
+      <tag>@$(__name__).tag
+      <toolset>gcc:<cxxflags>-Wno-long-long
+    : default-build <threading>multi
+    ;
+
+local rule default_threadapi ( )
+{
+    local api = pthread ;
+    if [ os.name ] = "NT" { api = win32 ; }
+    return $(api) ;
+}
+
+feature.feature threadapi : pthread win32 : propagated ;
+feature.set-default threadapi : [ default_threadapi ] ;
+
+rule tag ( name : type ? : property-set )
+{
+    local result = $(name) ;
+    
+    if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB
+    {
+        local api = [ $(property-set).get <threadapi> ] ;
+        
+        # non native api gets additional tag
+        if $(api) != [ default_threadapi ] {
+            result = $(result)_$(api) ;
+        }
+    }
+    
+    # forward to the boost tagging rule
+    return  [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag 
+                $(result) : $(type) : $(property-set) ] ;
+}
+
+rule win32_pthread_paths ( properties * )
+{
+    local result ;
+    local PTW32_INCLUDE ;
+    local PTW32_LIB ;
+    PTW32_INCLUDE  = [ modules.peek             : PTW32_INCLUDE ] ;
+    PTW32_LIB      = [ modules.peek             : PTW32_LIB     ] ;
+    PTW32_INCLUDE ?= [ modules.peek user-config : PTW32_INCLUDE ] ;
+    PTW32_LIB     ?= [ modules.peek user-config : PTW32_LIB     ] ;
+    PTW32_INCLUDE ?= [ modules.peek site-config : PTW32_INCLUDE ] ;
+    PTW32_LIB     ?= [ modules.peek site-config : PTW32_LIB     ] ;
+
+    if ! ( $(PTW32_INCLUDE) && $(PTW32_LIB) )
+    {
+        if  ! $(.notified)
+        {
+            echo "************************************************************" ;
+            echo "Trying to build Boost.Thread with pthread support."           ;
+            echo "If you need pthread you should specify the paths."            ;
+            echo "You can specify them in site-config.jam, user-config.jam"     ;
+            echo "or in the environment."                                       ;
+            echo "For example:"                                                 ;
+            echo "PTW32_INCLUDE=C:\\Program Files\\ptw32\\Pre-built2\\include"  ;
+            echo "PTW32_LIB=C:\\Program Files\\ptw32\\Pre-built2\\lib"          ;
+            echo "************************************************************" ;
+            .notified = true ;
+        }
+    }
+    else
+    {
+        local include_path = [ path.make $(PTW32_INCLUDE) ] ;
+        local lib_path = [ path.make $(PTW32_LIB) ] ;
+        local libname = pthread ;
+        if <toolset>msvc in $(properties)
+        {
+            libname = $(libname)VC2.lib ;
+        }
+        if <toolset>gcc in $(properties)
+        {
+            libname = lib$(libname)GC2.a ;
+        }
+        lib_path = [ path.glob $(lib_path) : $(libname) ] ;
+        if ! $(lib_path)
+        {
+            if  ! $(.notified)
+            {
+                echo "************************************************************" ;
+                echo "Trying to build Boost.Thread with pthread support."           ;
+                echo "But the library" $(libname) "could not be found in path"      ;
+                echo $(PTW32_LIB)                                                   ;
+                echo "************************************************************" ;
+                .notified = true ;
+            }
+        }
+        else 
+        {
+            result += <include>$(include_path) ;
+            result += <library>$(lib_path) ;
+        }
+    }
+    return $(result) ;
+}
+
+rule usage-requirements ( properties * )
+{
+    local result ;
+    if <threadapi>pthread in $(properties)
+    {
+        result += <define>BOOST_THREAD_POSIX ;
+        if <target-os>windows in $(properties)
+        {
+            result += [ win32_pthread_paths $(properties) ] ;
+            # TODO: What is for static linking? Is the <library> also needed
+            # in that case?
+        }
+    }
+    return $(result) ;
+}
+
+rule requirements ( properties * )
+{
+    local result ;
+
+    if <threadapi>pthread in $(properties)
+    {
+        result += <define>BOOST_THREAD_POSIX ;
+        if <target-os>windows in $(properties) 
+        {
+            local paths = [ win32_pthread_paths $(properties) ] ;
+            if $(paths)
+            {
+                result += $(paths) ;
+            }
+            else
+            {
+                result = <build>no ;
+            }
+        }
+    }
+    return $(result) ;
+}
+
+alias thread_sources
+    : ## win32 sources ##
+      win32/thread.cpp
+      win32/tss_dll.cpp
+      win32/tss_pe.cpp
+    : ## requirements ##
+      <threadapi>win32
+    ;
+
+alias thread_sources
+    : ## pthread sources ##
+      pthread/thread.cpp
+      pthread/once.cpp
+    : ## requirements ##
+      <threadapi>pthread
+    ;
+
+explicit thread_sources ;
+
+lib boost_thread
+    : thread_sources
+    : <conditional>@requirements
+    :
+    : <link>shared:<define>BOOST_THREAD_USE_DLL=1
+      <link>static:<define>BOOST_THREAD_USE_LIB=1
+      <conditional>@usage-requirements
+    ;

doc/Jamfile.v2

@@ -0,0 +1,31 @@
+# (C) Copyright 2008 Anthony Williams
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying 
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+path-constant boost-images : ../../../doc/src/images ;
+
+xml thread : thread.qbk ;
+
+boostbook standalone
+    :
+        thread
+    :
+        # HTML options first:
+        # Use graphics not text for navigation:
+        <xsl:param>navig.graphics=1
+        # How far down we chunk nested sections, basically all of them:
+        <xsl:param>chunk.section.depth=3
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=1
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=10
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=3
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=10
+        # Path for links to Boost:
+        <xsl:param>boost.root=../../../..
+    ;
+
+

doc/acknowledgements.qbk

@@ -0,0 +1,23 @@
+[/
+  (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
+version initially grew out of an attempt to rewrite __boost_thread__ to William Kempf's design with fresh code that could be
+released under the Boost Software License. However, as the C++ Standards committee have been actively discussing standardizing a
+thread library for C++, this library has evolved to reflect the proposals, whilst retaining as much backwards-compatibility as
+possible.
+
+Particular thanks must be given to Roland Schwarz, who contributed a lot of time and code to the original __boost_thread__ library,
+and who has been actively involved with the rewrite. The scheme for dividing the platform-specific implementations into separate
+directories was devised by Roland, and his input has contributed greatly to improving the quality of the current implementation.
+
+Thanks also must go to Peter Dimov, Howard Hinnant, Alexander Terekhov, Chris Thomasson and others for their comments on the
+implementation details of the code.
+
+[endsect]

doc/barrier.qbk

@@ -0,0 +1,72 @@
+[/
+  (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
+configured for a particular number of threads (`n`), and as threads reach the barrier they must wait until all `n` threads have
+arrived. Once the `n`-th thread has reached the barrier, all the waiting threads can proceed, and the barrier is reset.
+
+[section:barrier Class `barrier`]
+
+    #include <boost/thread/barrier.hpp>
+
+    class barrier
+    {
+    public:
+        barrier(unsigned int count);
+        ~barrier();
+
+        bool wait();
+    };
+
+Instances of __barrier__ are not copyable or movable.
+
+[heading Constructor]
+
+    barrier(unsigned int count);
+
+[variablelist
+
+[[Effects:] [Construct a barrier for `count` threads.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+[heading Destructor]
+
+    ~barrier();
+
+[variablelist
+
+[[Precondition:] [No threads are waiting on `*this`.]]
+
+[[Effects:] [Destroys `*this`.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[heading Member function `wait`]
+
+    bool wait();
+
+[variablelist
+
+[[Effects:] [Block until `count` threads have called `wait` on `*this`. When the `count`-th thread calls `wait`, all waiting threads
+are unblocked, and the barrier is reset. ]]
+
+[[Returns:] [`true` for exactly one thread from each batch of waiting threads, `false` otherwise.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+[endsect]
+
+[endsect]

doc/changes.qbk

@@ -0,0 +1,87 @@
+[/
+  (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.40]
+
+The 1.41.0 release of Boost adds futures to the thread library. There are also a few minor changes.
+
+[heading Changes since boost 1.35]
+
+The 1.36.0 release of Boost includes a few new features in the thread library:
+
+* New generic __lock_multiple_ref__ and __try_lock_multiple_ref__ functions for locking multiple mutexes at once.
+
+* Rvalue reference support for move semantics where the compilers supports it.
+
+* A few bugs fixed and missing functions added (including the serious win32 condition variable bug).
+
+* `scoped_try_lock` types are now backwards-compatible with Boost 1.34.0 and previous releases.
+
+* Support for passing function arguments to the thread function by supplying additional arguments to the __thread__ constructor.
+
+* Backwards-compatibility overloads added for `timed_lock` and `timed_wait` functions to allow use of `xtime` for timeouts.
+
+[heading Changes since boost 1.34]
+
+Almost every line of code in __boost_thread__ has been changed since the 1.34 release of boost. However, most of the interface
+changes have been extensions, so the new code is largely backwards-compatible with the old code. The new features and breaking
+changes are described below.
+
+[heading New Features]
+
+* Instances of __thread__ and of the various lock types are now movable.
+
+* Threads can be interrupted at __interruption_points__.
+
+* Condition variables can now be used with any type that implements the __lockable_concept__, through the use of
+`boost::condition_variable_any` (`boost::condition` is a `typedef` to `boost::condition_variable_any`, provided for backwards
+compatibility). `boost::condition_variable` is provided as an optimization, and will only work with
+`boost::unique_lock<boost::mutex>` (`boost::mutex::scoped_lock`).
+
+* Thread IDs are separated from __thread__, so a thread can obtain it's own ID (using `boost::this_thread::get_id()`), and IDs can
+be used as keys in associative containers, as they have the full set of comparison operators.
+
+* Timeouts are now implemented using the Boost DateTime library, through a typedef `boost::system_time` for absolute timeouts, and
+with support for relative timeouts in many cases. `boost::xtime` is supported for backwards compatibility only.
+
+* Locks are implemented as publicly accessible templates `boost::lock_guard`, `boost::unique_lock`, `boost::shared_lock`, and
+`boost::upgrade_lock`, which are templated on the type of the mutex. The __lockable_concept__ has been extended to include publicly
+available __lock_ref__ and __unlock_ref__ member functions, which are used by the lock types.
+
+[heading Breaking Changes]
+
+The list below should cover all changes to the public interface which break backwards compatibility.
+
+* __try_mutex__ has been removed, and the functionality subsumed into __mutex__. __try_mutex__ is left as a `typedef`,
+but is no longer a separate class.
+
+* __recursive_try_mutex__ has been removed, and the functionality subsumed into
+__recursive_mutex__. __recursive_try_mutex__ is left as a `typedef`, but is no longer a separate class.
+
+* `boost::detail::thread::lock_ops` has been removed. Code that relies on the `lock_ops` implementation detail will no longer work,
+as this has been removed, as it is no longer necessary now that mutex types now have public __lock_ref__ and __unlock_ref__ member
+functions.
+
+* `scoped_lock` constructors with a second parameter of type `bool` are no longer provided. With previous boost releases,
+``boost::mutex::scoped_lock some_lock(some_mutex,false);`` could be used to create a lock object that was associated with a mutex,
+but did not lock it on construction. This facility has now been replaced with the constructor that takes a
+`boost::defer_lock_type` as the second parameter: ``boost::mutex::scoped_lock some_lock(some_mutex,boost::defer_lock);``
+
+* The `locked()` member function of the `scoped_lock` types has been renamed to __owns_lock_ref__.
+
+* You can no longer obtain a __thread__ instance representing the current thread: a default-constructed __thread__ object is not
+associated with any thread. The only use for such a thread object was to support the comparison operators: this functionality has
+been moved to __thread_id__.
+
+* The broken `boost::read_write_mutex` has been replaced with __shared_mutex__.
+
+* __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]

doc/condition_variables.qbk

@@ -0,0 +1,513 @@
+[/
+  (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]
+
+The classes `condition_variable` and `condition_variable_any` provide a
+mechanism for one thread to wait for notification from another thread that a
+particular condition has become true. The general usage pattern is that one
+thread locks a mutex and then calls `wait` on an instance of
+`condition_variable` or `condition_variable_any`. When the thread is woken from
+the wait, then it checks to see if the appropriate condition is now true, and
+continues if so. If the condition is not true, then the thread then calls `wait`
+again to resume waiting. In the simplest case, this condition is just a boolean
+variable:
+
+    boost::condition_variable cond;
+    boost::mutex mut;
+    bool data_ready;
+
+    void process_data();
+
+    void wait_for_data_to_process()
+    {
+        boost::unique_lock<boost::mutex> lock(mut);
+        while(!data_ready)
+        {
+            cond.wait(lock);
+        }
+        process_data();
+    }
+
+Notice that the `lock` is passed to `wait`: `wait` will atomically add the
+thread to the set of threads waiting on the condition variable, and unlock the
+mutex. When the thread is woken, the mutex will be locked again before the call
+to `wait` returns. This allows other threads to acquire the mutex in order to
+update the shared data, and ensures that the data associated with the condition
+is correctly synchronized.
+
+In the mean time, another thread sets the condition to `true`, and then calls
+either `notify_one` or `notify_all` on the condition variable to wake one
+waiting thread or all the waiting threads respectively.
+
+    void retrieve_data();
+    void prepare_data();
+
+    void prepare_data_for_processing()
+    {
+        retrieve_data();
+        prepare_data();
+        {
+            boost::lock_guard<boost::mutex> lock(mut);
+            data_ready=true;
+        }
+        cond.notify_one();
+    }
+
+Note that the same mutex is locked before the shared data is updated, but that
+the mutex does not have to be locked across the call to `notify_one`.
+
+This example uses an object of type `condition_variable`, but would work just as
+well with an object of type `condition_variable_any`: `condition_variable_any`
+is more general, and will work with any kind of lock or mutex, whereas
+`condition_variable` requires that the lock passed to `wait` is an instance of
+`boost::unique_lock<boost::mutex>`. This enables `condition_variable` to make
+optimizations in some cases, based on the knowledge of the mutex type;
+`condition_variable_any` typically has a more complex implementation than
+`condition_variable`.
+
+[section:condition_variable Class `condition_variable`]
+
+    #include <boost/thread/condition_variable.hpp>
+
+    namespace boost
+    {
+        class condition_variable
+        {
+        public:
+            condition_variable();
+            ~condition_variable();
+
+            void notify_one();
+            void notify_all();
+
+            void wait(boost::unique_lock<boost::mutex>& lock);
+
+            template<typename predicate_type>
+            void wait(boost::unique_lock<boost::mutex>& lock,predicate_type predicate);
+
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time);
+
+            template<typename duration_type>
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time);
+
+            template<typename predicate_type>
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time,predicate_type predicate);
+
+            template<typename duration_type,typename predicate_type>
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time,predicate_type predicate);
+
+        // backwards compatibility
+
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time);
+
+            template<typename predicate_type>
+            bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time,predicate_type predicate);
+        };
+    }
+
+[section:constructor `condition_variable()`]
+
+[variablelist
+
+[[Effects:] [Constructs an object of class `condition_variable`.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+[endsect]
+
+[section:destructor `~condition_variable()`]
+
+[variablelist
+
+[[Precondition:] [All threads waiting on `*this` have been notified by a call to
+`notify_one` or `notify_all` (though the respective calls to `wait` or
+`timed_wait` need not have returned).]]
+
+[[Effects:] [Destroys the object.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:notify_one `void notify_one()`]
+
+[variablelist
+
+[[Effects:] [If any threads are currently __blocked__ waiting on `*this` in a call
+to `wait` or `timed_wait`, unblocks one of those threads.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:notify_all `void notify_all()`]
+
+[variablelist
+
+[[Effects:] [If any threads are currently __blocked__ waiting on `*this` in a call
+to `wait` or `timed_wait`, unblocks all of those threads.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:wait `void wait(boost::unique_lock<boost::mutex>& lock)`]
+
+[variablelist
+
+[[Precondition:] [`lock` is locked by the current thread, and either no other
+thread is currently waiting on `*this`, or the execution of the `mutex()` member
+function on the `lock` objects supplied in the calls to `wait` or `timed_wait`
+in all the threads currently waiting on `*this` would return the same value as
+`lock->mutex()` for this call to `wait`.]]
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, or spuriously. When the thread is unblocked (for whatever
+reason), the lock is reacquired by invoking `lock.lock()` before the call to
+`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
+function exits with an exception.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[endsect]
+
+[section:wait_predicate `template<typename predicate_type> void wait(boost::unique_lock<boost::mutex>& lock, predicate_type pred)`]
+
+[variablelist
+
+[[Effects:] [As-if ``
+while(!pred())
+{
+    wait(lock);
+}
+``]]
+
+]
+
+[endsect]
+
+[section:timed_wait `bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time)`]
+
+[variablelist
+
+[[Precondition:] [`lock` is locked by the current thread, and either no other
+thread is currently waiting on `*this`, or the execution of the `mutex()` member
+function on the `lock` objects supplied in the calls to `wait` or `timed_wait`
+in all the threads currently waiting on `*this` would return the same value as
+`lock->mutex()` for this call to `wait`.]]
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, when the time as reported by `boost::get_system_time()`
+would be equal to or later than the specified `abs_time`, or spuriously. When
+the thread is unblocked (for whatever reason), the lock is reacquired by
+invoking `lock.lock()` before the call to `wait` returns. The lock is also
+reacquired by invoking `lock.lock()` if the function exits with an exception.]]
+
+[[Returns:] [`false` if the call is returning because the time specified by
+`abs_time` was reached, `true` otherwise.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[endsect]
+
+[section:timed_wait_rel `template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time)`]
+
+[variablelist
+
+[[Precondition:] [`lock` is locked by the current thread, and either no other
+thread is currently waiting on `*this`, or the execution of the `mutex()` member
+function on the `lock` objects supplied in the calls to `wait` or `timed_wait`
+in all the threads currently waiting on `*this` would return the same value as
+`lock->mutex()` for this call to `wait`.]]
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, after the period of time indicated by the `rel_time`
+argument has elapsed, or spuriously. When the thread is unblocked (for whatever
+reason), the lock is reacquired by invoking `lock.lock()` before the call to
+`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
+function exits with an exception.]]
+
+[[Returns:] [`false` if the call is returning because the time period specified
+by `rel_time` has elapsed, `true` otherwise.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[note The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases.]
+
+[endsect]
+
+[section:timed_wait_predicate `template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock, boost::system_time const& abs_time, predicate_type pred)`]
+
+[variablelist
+
+[[Effects:] [As-if ``
+while(!pred())
+{
+    if(!timed_wait(lock,abs_time))
+    {
+        return pred();
+    }
+}
+return true;
+``]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[section:condition_variable_any Class `condition_variable_any`]
+
+    #include <boost/thread/condition_variable.hpp>
+
+    namespace boost
+    {
+        class condition_variable_any
+        {
+        public:
+            condition_variable_any();
+            ~condition_variable_any();
+
+            void notify_one();
+            void notify_all();
+
+            template<typename lock_type>
+            void wait(lock_type& lock);
+
+            template<typename lock_type,typename predicate_type>
+            void wait(lock_type& lock,predicate_type predicate);
+
+            template<typename lock_type>
+            bool timed_wait(lock_type& lock,boost::system_time const& abs_time);
+
+            template<typename lock_type,typename duration_type>
+            bool timed_wait(lock_type& lock,duration_type const& rel_time);
+
+            template<typename lock_type,typename predicate_type>
+            bool timed_wait(lock_type& lock,boost::system_time const& abs_time,predicate_type predicate);
+
+            template<typename lock_type,typename duration_type,typename predicate_type>
+            bool timed_wait(lock_type& lock,duration_type const& rel_time,predicate_type predicate);
+
+        // backwards compatibility
+
+            template<typename lock_type>
+            bool timed_wait(lock_type>& lock,boost::xtime const& abs_time);
+
+            template<typename lock_type,typename predicate_type>
+            bool timed_wait(lock_type& lock,boost::xtime const& abs_time,predicate_type predicate);
+        };
+    }
+
+[section:constructor `condition_variable_any()`]
+
+[variablelist
+
+[[Effects:] [Constructs an object of class `condition_variable_any`.]]
+
+[[Throws:] [__thread_resource_error__ if an error occurs.]]
+
+]
+
+[endsect]
+
+[section:destructor `~condition_variable_any()`]
+
+[variablelist
+
+[[Precondition:] [All threads waiting on `*this` have been notified by a call to
+`notify_one` or `notify_all` (though the respective calls to `wait` or
+`timed_wait` need not have returned).]]
+
+[[Effects:] [Destroys the object.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:notify_one `void notify_one()`]
+
+[variablelist
+
+[[Effects:] [If any threads are currently __blocked__ waiting on `*this` in a call
+to `wait` or `timed_wait`, unblocks one of those threads.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:notify_all `void notify_all()`]
+
+[variablelist
+
+[[Effects:] [If any threads are currently __blocked__ waiting on `*this` in a call
+to `wait` or `timed_wait`, unblocks all of those threads.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:wait `template<typename lock_type> void wait(lock_type& lock)`]
+
+[variablelist
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, or spuriously. When the thread is unblocked (for whatever
+reason), the lock is reacquired by invoking `lock.lock()` before the call to
+`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
+function exits with an exception.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[endsect]
+
+[section:wait_predicate `template<typename lock_type,typename predicate_type> void wait(lock_type& lock, predicate_type pred)`]
+
+[variablelist
+
+[[Effects:] [As-if ``
+while(!pred())
+{
+    wait(lock);
+}
+``]]
+
+]
+
+[endsect]
+
+[section:timed_wait `template<typename lock_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time)`]
+
+[variablelist
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, when the time as reported by `boost::get_system_time()`
+would be equal to or later than the specified `abs_time`, or spuriously. When
+the thread is unblocked (for whatever reason), the lock is reacquired by
+invoking `lock.lock()` before the call to `wait` returns. The lock is also
+reacquired by invoking `lock.lock()` if the function exits with an exception.]]
+
+[[Returns:] [`false` if the call is returning because the time specified by
+`abs_time` was reached, `true` otherwise.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[endsect]
+
+[section:timed_wait_rel `template<typename lock_type,typename duration_type> bool timed_wait(lock_type& lock,duration_type const& rel_time)`]
+
+[variablelist
+
+[[Effects:] [Atomically call `lock.unlock()` and blocks the current thread. The
+thread will unblock when notified by a call to `this->notify_one()` or
+`this->notify_all()`, after the period of time indicated by the `rel_time`
+argument has elapsed, or spuriously. When the thread is unblocked (for whatever
+reason), the lock is reacquired by invoking `lock.lock()` before the call to
+`wait` returns. The lock is also reacquired by invoking `lock.lock()` if the
+function exits with an exception.]]
+
+[[Returns:] [`false` if the call is returning because the time period specified
+by `rel_time` has elapsed, `true` otherwise.]]
+
+[[Postcondition:] [`lock` is locked by the current thread.]]
+
+[[Throws:] [__thread_resource_error__ if an error
+occurs. __thread_interrupted__ if the wait was interrupted by a call to
+__interrupt__ on the __thread__ object associated with the current thread of execution.]]
+
+]
+
+[note The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases.]
+
+[endsect]
+
+[section:timed_wait_predicate `template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock, boost::system_time const& abs_time, predicate_type pred)`]
+
+[variablelist
+
+[[Effects:] [As-if ``
+while(!pred())
+{
+    if(!timed_wait(lock,abs_time))
+    {
+        return pred();
+    }
+}
+return true;
+``]]
+
+]
+
+[endsect]
+
+[endsect]
+
+[section:condition Typedef `condition`]
+
+    #include <boost/thread/condition.hpp>
+
+    typedef condition_variable_any condition;
+
+The typedef `condition` is provided for backwards compatibility with previous boost releases.
+
+[endsect]
+
+[endsect]

doc/future_ref.qbk

@@ -0,0 +1,968 @@
+[/
+  (C) Copyright 2008-9 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:reference Futures Reference]
+
+[section:future_state `state` enum]
+
+    namespace future_state
+    {
+        enum state {uninitialized, waiting, ready};
+    }
+
+[endsect]
+
+[section:unique_future `unique_future` class template]
+
+    template <typename R>
+    class unique_future
+    {
+        unique_future(unique_future & rhs);// = delete;
+        unique_future& operator=(unique_future& rhs);// = delete;
+
+    public:
+        typedef future_state::state state;
+
+        unique_future();
+        ~unique_future();
+
+        // move support
+        unique_future(unique_future && other);
+        unique_future& operator=(unique_future && other);
+
+        void swap(unique_future& other);
+
+        // retrieving the value
+        R&& get();        
+
+        // functions to check state
+        state get_state() const;
+        bool is_ready() const;        
+        bool has_exception() const;        
+        bool has_value() const;        
+
+        // waiting for the result to be ready
+        void wait() const;        
+        template<typename Duration>
+        bool timed_wait(Duration const& rel_time) const;
+        bool timed_wait_until(boost::system_time const& abs_time) const;
+    };
+
+[section:default_constructor Default Constructor]
+
+    unique_future();
+
+[variablelist
+
+[[Effects:] [Constructs an uninitialized future.]]
+
+[[Postconditions:] [[unique_future_is_ready_link `this->is_ready`] returns `false`. [unique_future_get_state_link
+`this->get_state()`] returns __uninitialized__.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:destructor Destructor]
+
+    ~unique_future();
+
+[variablelist
+
+[[Effects:] [Destroys `*this`.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:move_constructor Move Constructor]
+
+    unique_future(unique_future && other);
+
+[variablelist
+
+[[Effects:] [Constructs a new future, and transfers ownership of the asynchronous result associated with `other` to `*this`.]]
+
+[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
+call. `other->get_state()` returns __uninitialized__. If `other` was associated with an asynchronous result, that result is now
+associated with `*this`. `other` is not associated with any asynchronous result.]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:move_assignment Move Assignment Operator]
+
+    unique_future& operator=(unique_future && other);
+
+[variablelist
+
+[[Effects:] [Transfers ownership of the asynchronous result associated with `other` to `*this`.]]
+
+[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
+call. `other->get_state()` returns __uninitialized__. If `other` was associated with an asynchronous result, that result is now
+associated with `*this`. `other` is not associated with any asynchronous result. If `*this` was associated with an asynchronous
+result prior to the call, that result no longer has an associated __unique_future__ instance.]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:swap Member function `swap()`]
+
+    void swap(unique_future & other);
+
+[variablelist
+
+[[Effects:] [Swaps ownership of the asynchronous results associated with `other` and `*this`.]]
+
+[[Postconditions:] [[unique_future_get_state_link `this->get_state()`] returns the value of `other->get_state()` prior to the
+call. `other->get_state()` returns the value of `this->get_state()` prior to the call. If `other` was associated with an
+asynchronous result, that result is now associated with `*this`, otherwise `*this` has no associated result. If `*this` was
+associated with an asynchronous result, that result is now associated with `other`, otherwise `other` has no associated result.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[section:get Member function `get()`]
+
+    R&& get();
+    R& unique_future<R&>::get();
+    void unique_future<void>::get();
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready as-if by a call to
+__unique_future_wait__, and retrieves the result (whether that is a value or an exception).]]
+
+[[Returns:] [If the result type `R` is a reference, returns the stored reference. If `R` is `void`, there is no return
+value. Otherwise, returns an rvalue-reference to the value stored in the asynchronous result.]]
+
+[[Postconditions:] [[unique_future_is_ready_link `this->is_ready()`] returns `true`. [unique_future_get_state_link
+`this->get_state()`] returns __ready__.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception stored in the
+asynchronous result in place of a value.]]
+
+[[Notes:] [`get()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:wait Member function `wait()`]
+
+    void wait();
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready. If the result is not ready on
+entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [[unique_future_is_ready_link `this->is_ready()`] returns `true`. [unique_future_get_state_link
+`this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`wait()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:timed_wait_duration Member function `timed_wait()`]
+
+    template<typename Duration>
+    bool timed_wait(Duration const& wait_duration);
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time specified by
+`wait_duration` has elapsed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is
+invoked prior to waiting.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
+elapsed, `false` otherwise.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [If this call returned `true`, then [unique_future_is_ready_link `this->is_ready()`] returns `true` and
+[unique_future_get_state_link `this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`timed_wait()` is an ['interruption point]. `Duration` must be a type that meets the Boost.DateTime time duration requirements.]]
+
+]
+
+[endsect]
+
+[section:timed_wait_absolute Member function `timed_wait()`]
+
+    bool timed_wait(boost::system_time const& wait_timeout);
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time point specified by
+`wait_timeout` has passed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is invoked
+prior to waiting.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
+passed, `false` otherwise.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [If this call returned `true`, then [unique_future_is_ready_link `this->is_ready()`] returns `true` and
+[unique_future_get_state_link `this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`timed_wait()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+
+[section:is_ready Member function `is_ready()`]
+
+    bool is_ready();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready for retrieval, `false`
+otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:has_value Member function `has_value()`]
+
+    bool has_value();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with a value rather than an exception.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
+stored value, `false` otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:has_exception Member function `has_exception()`]
+
+    bool has_exception();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with an exception rather than a value.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
+stored exception, `false` otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get_state Member function `get_state()`]
+
+    future_state::state get_state();
+
+[variablelist
+
+[[Effects:] [Determine the state of the asynchronous result associated with `*this`, if any.]]
+
+[[Returns:] [__uninitialized__ if `*this` is not associated with an asynchronous result. __ready__ if the asynchronous result
+associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[section:shared_future `shared_future` class template]
+
+    template <typename R>
+    class shared_future
+    {
+    public:
+        typedef future_state::state state;
+
+        shared_future();
+        ~shared_future();
+
+        // copy support
+        shared_future(shared_future const& other);
+        shared_future& operator=(shared_future const& other);
+
+        // move support
+        shared_future(shared_future && other);
+        shared_future(unique_future<R> && other);
+        shared_future& operator=(shared_future && other);
+        shared_future& operator=(unique_future<R> && other);
+
+        void swap(shared_future& other);
+
+        // retrieving the value
+        R get();
+        
+        // functions to check state, and wait for ready
+        state get_state() const;
+        bool is_ready() const;
+        bool has_exception() const;
+        bool has_value() const;
+
+        // waiting for the result to be ready
+        void wait() const;        
+        template<typename Duration>
+        bool timed_wait(Duration const& rel_time) const;
+        bool timed_wait_until(boost::system_time const& abs_time) const;        
+    };
+
+[section:default_constructor Default Constructor]
+
+    shared_future();
+
+[variablelist
+
+[[Effects:] [Constructs an uninitialized future.]]
+
+[[Postconditions:] [[shared_future_is_ready_link `this->is_ready`] returns `false`. [shared_future_get_state_link
+`this->get_state()`] returns __uninitialized__.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get Member function `get()`]
+
+    const R& get();
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready as-if by a call to
+__shared_future_wait__, and returns a `const` reference to the result.]]
+
+[[Returns:] [If the result type `R` is a reference, returns the stored reference. If `R` is `void`, there is no return
+value. Otherwise, returns a `const` reference to the value stored in the asynchronous result.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the
+result associated with `*this` is not ready at the point of the call, and the current thread is interrupted.]]
+
+[[Notes:] [`get()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:wait Member function `wait()`]
+
+    void wait();
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready. If the result is not ready on
+entry, and the result has a ['wait callback] set, that callback is invoked prior to waiting.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [[shared_future_is_ready_link `this->is_ready()`] returns `true`. [shared_future_get_state_link
+`this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`wait()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:timed_wait_duration Member function `timed_wait()`]
+
+    template<typename Duration>
+    bool timed_wait(Duration const& wait_duration);
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time specified by
+`wait_duration` has elapsed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is
+invoked prior to waiting.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
+elapsed, `false` otherwise.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [If this call returned `true`, then [shared_future_is_ready_link `this->is_ready()`] returns `true` and
+[shared_future_get_state_link `this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`timed_wait()` is an ['interruption point]. `Duration` must be a type that meets the Boost.DateTime time duration requirements.]]
+
+]
+
+[endsect]
+
+[section:timed_wait_absolute Member function `timed_wait()`]
+
+    bool timed_wait(boost::system_time const& wait_timeout);
+
+[variablelist
+
+[[Effects:] [If `*this` is associated with an asynchronous result, waits until the result is ready, or the time point specified by
+`wait_timeout` has passed. If the result is not ready on entry, and the result has a ['wait callback] set, that callback is invoked
+prior to waiting.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready before the specified time has
+passed, `false` otherwise.]]
+
+[[Throws:] [__future_uninitialized__ if `*this` is not associated with an asynchronous result. __thread_interrupted__ if the result
+associated with `*this` is not ready at the point of the call, and the current thread is interrupted. Any exception thrown by the
+['wait callback] if such a callback is called.]]
+
+[[Postconditions:] [If this call returned `true`, then [shared_future_is_ready_link `this->is_ready()`] returns `true` and
+[shared_future_get_state_link `this->get_state()`] returns __ready__.]]
+
+[[Notes:] [`timed_wait()` is an ['interruption point].]]
+
+]
+
+[endsect]
+
+[section:is_ready Member function `is_ready()`]
+
+    bool is_ready();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, and that result is ready for retrieval, `false`
+otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:has_value Member function `has_value()`]
+
+    bool has_value();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with a value rather than an exception.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
+stored value, `false` otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:has_exception Member function `has_exception()`]
+
+    bool has_exception();
+
+[variablelist
+
+[[Effects:] [Checks to see if the asynchronous result associated with `*this` is set with an exception rather than a value.]]
+
+[[Returns:] [`true` if `*this` is associated with an asynchronous result, that result is ready for retrieval, and the result is a
+stored exception, `false` otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get_state Member function `get_state()`]
+
+    future_state::state get_state();
+
+[variablelist
+
+[[Effects:] [Determine the state of the asynchronous result associated with `*this`, if any.]]
+
+[[Returns:] [__uninitialized__ if `*this` is not associated with an asynchronous result. __ready__ if the asynchronous result
+associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[section:promise `promise` class template]
+
+    template <typename R>
+    class promise
+    {
+        promise(promise & rhs);// = delete;
+        promise & operator=(promise & rhs);// = delete;
+    public:
+        // template <class Allocator> explicit promise(Allocator a);
+
+        promise();
+        ~promise();
+
+        // Move support
+        promise(promise && rhs);
+        promise & operator=(promise&& rhs);
+        
+        void swap(promise& other);
+        // Result retrieval
+        unique_future<R> get_future();
+
+        // Set the value
+        void set_value(R& r);
+        void set_value(R&& r);
+        void set_exception(boost::exception_ptr e);
+
+        template<typename F>
+        void set_wait_callback(F f);        
+    };
+
+[section:default_constructor Default Constructor]
+
+    promise();
+
+[variablelist
+
+[[Effects:] [Constructs a new __promise__ with no associated result.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:move_constructor Move Constructor]
+
+    promise(promise && other);
+
+[variablelist
+
+[[Effects:] [Constructs a new __promise__, and transfers ownership of the result associated with `other` to `*this`, leaving `other`
+with no associated result.]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:move_assignment Move Assignment Operator]
+
+    promise& operator=(promise && other);
+
+[variablelist
+
+[[Effects:] [Transfers ownership of the result associated with `other` to `*this`, leaving `other` with no associated result. If there
+was already a result associated with `*this`, and that result was not ['ready], sets any futures associated with that result to
+['ready] with a __broken_promise__ exception as the result. ]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:destructor Destructor]
+
+    ~promise();
+
+[variablelist
+
+[[Effects:] [Destroys `*this`. If there was a result associated with `*this`, and that result is not ['ready], sets any futures
+associated with that task to ['ready] with a __broken_promise__ exception as the result.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get_future Member Function `get_future()`]
+
+    unique_future<R> get_future();
+
+[variablelist
+
+[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
+`*this`. Returns a __unique_future__ associated with the result associated with `*this`. ]]
+
+[[Throws:] [__future_already_retrieved__ if the future associated with the task has already been retrieved. `std::bad_alloc` if any
+memory necessary could not be allocated.]]
+
+]
+
+[endsect]
+
+[section:set_value Member Function `set_value()`]
+
+    void set_value(R&& r);
+    void set_value(const R& r);
+    void promise<R&>::set_value(R& r);
+    void promise<void>::set_value();
+
+[variablelist
+
+[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
+`*this`. Store the value `r` in the asynchronous result associated with `*this`. Any threads blocked waiting for the asynchronous
+result are woken.]]
+
+[[Postconditions:] [All futures waiting on the asynchronous result are ['ready] and __unique_future_has_value__ or
+__shared_future_has_value__ for those futures shall return `true`.]]
+
+[[Throws:] [__promise_already_satisfied__ if the result associated with `*this` is already ['ready]. `std::bad_alloc` if the memory
+required for storage of the result cannot be allocated. Any exception thrown by the copy or move-constructor of `R`.]]
+
+]
+
+[endsect]
+
+[section:set_exception Member Function `set_exception()`]
+
+    void set_exception(boost::exception_ptr e);
+
+[variablelist
+
+[[Effects:] [If `*this` was not associated with a result, allocate storage for a new asynchronous result and associate it with
+`*this`. Store the exception `e` in the asynchronous result associated with `*this`. Any threads blocked waiting for the asynchronous
+result are woken.]]
+
+[[Postconditions:] [All futures waiting on the asynchronous result are ['ready] and __unique_future_has_exception__ or
+__shared_future_has_exception__ for those futures shall return `true`.]]
+
+[[Throws:] [__promise_already_satisfied__ if the result associated with `*this` is already ['ready]. `std::bad_alloc` if the memory
+required for storage of the result cannot be allocated.]]
+
+]
+
+[endsect]
+
+[section:set_wait_callback Member Function `set_wait_callback()`]
+
+    template<typename F>
+    void set_wait_callback(F f);
+
+[variablelist
+
+[[Preconditions:] [The expression `f(t)` where `t` is a lvalue of type __packaged_task__ shall be well-formed. Invoking a copy of
+`f` shall have the same effect as invoking `f`]]
+
+[[Effects:] [Store a copy of `f` with the asynchronous result associated with `*this` as a ['wait callback]. This will replace any
+existing wait callback store alongside that result. If a thread subsequently calls one of the wait functions on a __unique_future__
+or __shared_future__ associated with this result, and the result is not ['ready], `f(*this)` shall be invoked.]]
+
+[[Throws:] [`std::bad_alloc` if memory cannot be allocated for the required storage.]]
+
+]
+
+[endsect]
+
+[endsect]
+
+[section:packaged_task `packaged_task` class template]
+
+    template<typename R>
+    class packaged_task
+    {
+        packaged_task(packaged_task&);// = delete;
+        packaged_task& operator=(packaged_task&);// = delete;
+        
+    public:
+        // construction and destruction
+        template <class F>
+        explicit packaged_task(F const& f);
+
+        explicit packaged_task(R(*f)());
+        
+        template <class F>
+        explicit packaged_task(F&& f);
+
+        // template <class F, class Allocator>
+        // explicit packaged_task(F const& f, Allocator a);
+        // template <class F, class Allocator>
+        // explicit packaged_task(F&& f, Allocator a);
+
+        ~packaged_task()
+        {}
+
+        // move support
+        packaged_task(packaged_task&& other);
+        packaged_task& operator=(packaged_task&& other);
+
+        void swap(packaged_task& other);
+        // result retrieval
+        unique_future<R> get_future();        
+
+        // execution
+        void operator()();
+
+        template<typename F>
+        void set_wait_callback(F f);        
+    };
+
+[section:task_constructor Task Constructor]
+
+    template<typename F>
+    packaged_task(F const &f);
+
+    packaged_task(R(*f)());
+
+    template<typename F>
+    packaged_task(F&&f);
+
+[variablelist
+
+[[Preconditions:] [`f()` is a valid expression with a return type convertible to `R`. Invoking a copy of `f` shall behave the same
+as invoking `f`.]]
+
+[[Effects:] [Constructs a new __packaged_task__ with a copy of `f` stored as the associated task.]]
+
+[[Throws:] [Any exceptions thrown by the copy (or move) constructor of `f`. `std::bad_alloc` if memory for the internal data
+structures could not be allocated.]]
+
+]
+
+[endsect]
+
+[section:move_constructor Move Constructor]
+
+    packaged_task(packaged_task && other);
+
+[variablelist
+
+[[Effects:] [Constructs a new __packaged_task__, and transfers ownership of the task associated with `other` to `*this`, leaving `other`
+with no associated task.]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:move_assignment Move Assignment Operator]
+
+    packaged_task& operator=(packaged_task && other);
+
+[variablelist
+
+[[Effects:] [Transfers ownership of the task associated with `other` to `*this`, leaving `other` with no associated task. If there
+was already a task associated with `*this`, and that task has not been invoked, sets any futures associated with that task to
+['ready] with a __broken_promise__ exception as the result. ]]
+
+[[Throws:] [Nothing.]]
+
+[[Notes:] [If the compiler does not support rvalue-references, this is implemented using the boost.thread move emulation.]]
+
+]
+
+[endsect]
+
+[section:destructor Destructor]
+
+    ~packaged_task();
+
+[variablelist
+
+[[Effects:] [Destroys `*this`. If there was a task associated with `*this`, and that task has not been invoked, sets any futures
+associated with that task to ['ready] with a __broken_promise__ exception as the result.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:get_future Member Function `get_future()`]
+
+    unique_future<R> get_future();
+
+[variablelist
+
+[[Effects:] [Returns a __unique_future__ associated with the result of the task associated with `*this`. ]]
+
+[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
+__packaged_task__. __future_already_retrieved__ if the future associated with the task has already been retrieved.]]
+
+]
+
+[endsect]
+
+[section:call_operator Member Function `operator()()`]
+
+    void operator()();
+
+[variablelist
+
+[[Effects:] [Invoke the task associated with `*this` and store the result in the corresponding future. If the task returns normally,
+the return value is stored as the asynchronous result, otherwise the exception thrown is stored. Any threads blocked waiting for the
+asynchronous result associated with this task are woken.]]
+
+[[Postconditions:] [All futures waiting on the asynchronous result are ['ready]]]
+
+[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
+__packaged_task__. __task_already_started__ if the task has already been invoked.]]
+
+]
+
+[endsect]
+
+[section:set_wait_callback Member Function `set_wait_callback()`]
+
+    template<typename F>
+    void set_wait_callback(F f);
+
+[variablelist
+
+[[Preconditions:] [The expression `f(t)` where `t` is a lvalue of type __packaged_task__ shall be well-formed. Invoking a copy of
+`f` shall have the same effect as invoking `f`]]
+
+[[Effects:] [Store a copy of `f` with the task associated with `*this` as a ['wait callback]. This will replace any existing wait
+callback store alongside that task. If a thread subsequently calls one of the wait functions on a __unique_future__ or
+__shared_future__ associated with this task, and the result of the task is not ['ready], `f(*this)` shall be invoked.]]
+
+[[Throws:] [__task_moved__ if ownership of the task associated with `*this` has been moved to another instance of
+__packaged_task__.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[section:wait_for_any Non-member function `wait_for_any()`]
+
+    template<typename Iterator>
+    Iterator wait_for_any(Iterator begin,Iterator end);
+
+    template<typename F1,typename F2>
+    unsigned wait_for_any(F1& f1,F2& f2);
+
+    template<typename F1,typename F2,typename F3>
+    unsigned wait_for_any(F1& f1,F2& f2,F3& f3);
+
+    template<typename F1,typename F2,typename F3,typename F4>
+    unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4);
+
+    template<typename F1,typename F2,typename F3,typename F4,typename F5>
+    unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5);
+
+[variablelist
+
+[[Preconditions:] [The types `Fn` shall be specializations of
+__unique_future__ or __shared_future__, and `Iterator` shall be a
+forward iterator with a `value_type` which is a specialization of
+__unique_future__ or __shared_future__.]]
+
+[[Effects:] [Waits until at least one of the specified futures is ['ready].]]
+
+[[Returns:] [The range-based overload returns an `Iterator` identifying the first future in the range that was detected as
+['ready]. The remaining overloads return the zero-based index of the first future that was detected as ['ready] (first parameter =>
+0, second parameter => 1, etc.).]]
+
+[[Throws:] [__thread_interrupted__ if the current thread is interrupted. Any exception thrown by the ['wait callback] associated
+with any of the futures being waited for.  `std::bad_alloc` if memory could not be allocated for the internal wait structures.]]
+
+[[Notes:] [`wait_for_any()` is an ['interruption point].]]
+
+]
+
+
+[endsect]
+
+[section:wait_for_all Non-member function `wait_for_all()`]
+
+    template<typename Iterator>
+    void wait_for_all(Iterator begin,Iterator end);
+
+    template<typename F1,typename F2>
+    void wait_for_all(F1& f1,F2& f2);
+
+    template<typename F1,typename F2,typename F3>
+    void wait_for_all(F1& f1,F2& f2,F3& f3);
+
+    template<typename F1,typename F2,typename F3,typename F4>
+    void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4);
+
+    template<typename F1,typename F2,typename F3,typename F4,typename F5>
+    void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5);
+
+[variablelist
+
+[[Preconditions:] [The types `Fn` shall be specializations of
+__unique_future__ or __shared_future__, and `Iterator` shall be a
+forward iterator with a `value_type` which is a specialization of
+__unique_future__ or __shared_future__.]]
+
+[[Effects:] [Waits until all of the specified futures are ['ready].]]
+
+[[Throws:] [Any exceptions thrown by a call to `wait()` on the specified futures.]]
+
+[[Notes:] [`wait_for_all()` is an ['interruption point].]]
+
+]
+
+
+[endsect]
+
+
+[endsect]

doc/futures.qbk

@@ -0,0 +1,187 @@
+[/
+  (C) Copyright 2008-9 Anthony Williams.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:futures Futures]
+
+[template future_state_link[link_text] [link thread.synchronization.futures.reference.future_state [link_text]]]
+[def __uninitialized__ [future_state_link `boost::future_state::uninitialized`]]
+[def __ready__ [future_state_link `boost::future_state::ready`]]
+[def __waiting__ [future_state_link `boost::future_state::waiting`]]
+
+[def __future_uninitialized__ `boost::future_uninitialized`]
+[def __broken_promise__ `boost::broken_promise`]
+[def __future_already_retrieved__ `boost::future_already_retrieved`]
+[def __task_moved__ `boost::task_moved`]
+[def __task_already_started__ `boost::task_already_started`]
+[def __promise_already_satisfied__ `boost::promise_already_satisfied`]
+
+[def __thread_interrupted__ `boost::thread_interrupted`]
+
+
+[template unique_future_link[link_text] [link thread.synchronization.futures.reference.unique_future [link_text]]]
+[def __unique_future__ [unique_future_link `boost::unique_future`]]
+
+[template unique_future_get_link[link_text] [link thread.synchronization.futures.reference.unique_future.get [link_text]]]
+[def __unique_future_get__ [unique_future_get_link `boost::unique_future<R>::get()`]]
+
+[template unique_future_wait_link[link_text] [link thread.synchronization.futures.reference.unique_future.wait [link_text]]]
+[def __unique_future_wait__ [unique_future_wait_link `boost::unique_future<R>::wait()`]]
+
+[template unique_future_is_ready_link[link_text] [link thread.synchronization.futures.reference.unique_future.is_ready [link_text]]]
+[def __unique_future_is_ready__ [unique_future_is_ready_link `boost::unique_future<R>::is_ready()`]]
+
+[template unique_future_has_value_link[link_text] [link thread.synchronization.futures.reference.unique_future.has_value [link_text]]]
+[def __unique_future_has_value__ [unique_future_has_value_link `boost::unique_future<R>::has_value()`]]
+
+[template unique_future_has_exception_link[link_text] [link thread.synchronization.futures.reference.unique_future.has_exception [link_text]]]
+[def __unique_future_has_exception__ [unique_future_has_exception_link `boost::unique_future<R>::has_exception()`]]
+
+[template unique_future_get_state_link[link_text] [link thread.synchronization.futures.reference.unique_future.get_state [link_text]]]
+[def __unique_future_get_state__ [unique_future_get_state_link `boost::unique_future<R>::get_state()`]]
+
+[template shared_future_link[link_text] [link thread.synchronization.futures.reference.shared_future [link_text]]]
+[def __shared_future__ [shared_future_link `boost::shared_future`]]
+
+[template shared_future_get_link[link_text] [link thread.synchronization.futures.reference.shared_future.get [link_text]]]
+[def __shared_future_get__ [shared_future_get_link `boost::shared_future<R>::get()`]]
+
+[template shared_future_wait_link[link_text] [link thread.synchronization.futures.reference.shared_future.wait [link_text]]]
+[def __shared_future_wait__ [shared_future_wait_link `boost::shared_future<R>::wait()`]]
+
+[template shared_future_is_ready_link[link_text] [link thread.synchronization.futures.reference.shared_future.is_ready [link_text]]]
+[def __shared_future_is_ready__ [shared_future_is_ready_link `boost::shared_future<R>::is_ready()`]]
+
+[template shared_future_has_value_link[link_text] [link thread.synchronization.futures.reference.shared_future.has_value [link_text]]]
+[def __shared_future_has_value__ [shared_future_has_value_link `boost::shared_future<R>::has_value()`]]
+
+[template shared_future_has_exception_link[link_text] [link thread.synchronization.futures.reference.shared_future.has_exception [link_text]]]
+[def __shared_future_has_exception__ [shared_future_has_exception_link `boost::shared_future<R>::has_exception()`]]
+
+[template shared_future_get_state_link[link_text] [link thread.synchronization.futures.reference.shared_future.get_state [link_text]]]
+[def __shared_future_get_state__ [shared_future_get_state_link `boost::shared_future<R>::get_state()`]]
+
+[template promise_link[link_text] [link thread.synchronization.futures.reference.promise [link_text]]]
+[def __promise__ [promise_link `boost::promise`]]
+
+[template packaged_task_link[link_text] [link thread.synchronization.futures.reference.packaged_task [link_text]]]
+[def __packaged_task__ [packaged_task_link `boost::packaged_task`]]
+
+[template wait_for_any_link[link_text] [link thread.synchronization.futures.reference.wait_for_any [link_text]]]
+[def __wait_for_any__ [wait_for_any_link `boost::wait_for_any()`]]
+
+[template wait_for_all_link[link_text] [link thread.synchronization.futures.reference.wait_for_all [link_text]]]
+[def __wait_for_all__ [wait_for_all_link `boost::wait_for_all()`]]
+
+
+[section:overview Overview]
+
+The futures library provides a means of handling synchronous future values, whether those values are generated by another thread, or
+on a single thread in response to external stimuli, or on-demand.
+
+This is done through the provision of four class templates: __unique_future__ and __shared_future__ which are used to retrieve the
+asynchronous results, and __promise__ and __packaged_task__ which are used to generate the asynchronous results.
+
+An instance of __unique_future__ holds the one and only reference to a result. Ownership can be transferred between instances using
+the move constructor or move-assignment operator, but at most one instance holds a reference to a given asynchronous result. When
+the result is ready, it is returned from __unique_future_get__ by rvalue-reference to allow the result to be moved or copied as
+appropriate for the type.
+
+On the other hand, many instances of __shared_future__ may reference the same result. Instances can be freely copied and assigned,
+and __shared_future_get__ returns a `const` reference so that multiple calls to __shared_future_get__ are safe. You can move an
+instance of __unique_future__ into an instance of __shared_future__, thus transferring ownership of the associated asynchronous
+result, but not vice-versa.
+
+You can wait for futures either individually or with one of the __wait_for_any__ and __wait_for_all__ functions.
+
+[endsect]
+
+[section:creating Creating asynchronous values]
+
+You can set the value in a future with either a __promise__ or a __packaged_task__. A __packaged_task__ is a callable object that
+wraps a function or callable object. When the packaged task is invoked, it invokes the contained function in turn, and populates a
+future with the return value. This is an answer to the perennial question: "how do I return a value from a thread?": package the
+function you wish to run as a __packaged_task__ and pass the packaged task to the thread constructor. The future retrieved from the
+packaged task can then be used to obtain the return value. If the function throws an exception, that is stored in the future in
+place of the return value.
+
+    int calculate_the_answer_to_life_the_universe_and_everything()
+    {
+        return 42;
+    }
+
+    boost::packaged_task<int> pt(calculate_the_answer_to_life_the_universe_and_everything);
+    boost::unique_future<int> fi=pt.get_future();
+
+    boost::thread task(boost::move(pt)); // launch task on a thread
+
+    fi.wait(); // wait for it to finish
+        
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+    assert(fi.get()==42);
+
+
+A __promise__ is a bit more low level: it just provides explicit functions to store a value or an exception in the associated
+future. A promise can therefore be used where the value may come from more than one possible source, or where a single operation may
+produce multiple values.
+
+    boost::promise<int> pi;
+    boost::unique_future<int> fi;
+    fi=pi.get_future();
+
+    pi.set_value(42);
+    
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+    assert(fi.get()==42);
+
+[endsect]
+
+[section:lazy_futures Wait Callbacks and Lazy Futures]
+
+Both __promise__ and __packaged_task__ support ['wait callbacks] that are invoked when a thread blocks in a call to `wait()` or
+`timed_wait()` on a future that is waiting for the result from the __promise__ or __packaged_task__, in the thread that is doing the
+waiting. These can be set using the `set_wait_callback()` member function on the __promise__ or __packaged_task__ in question.
+
+This allows ['lazy futures] where the result is not actually computed until it is needed by some thread. In the example below, the
+call to `f.get()` invokes the callback `invoke_lazy_task`, which runs the task to set the value. If you remove the call to
+`f.get()`, the task is not ever run.
+
+    int calculate_the_answer_to_life_the_universe_and_everything()
+    {
+        return 42;
+    }
+
+    void invoke_lazy_task(boost::packaged_task<int>& task)
+    {
+        try
+        {
+            task();
+        }
+        catch(boost::task_already_started&)
+        {}
+    }
+
+    int main()
+    {
+        boost::packaged_task<int> task(calculate_the_answer_to_life_the_universe_and_everything);
+        task.set_wait_callback(invoke_lazy_task);
+        boost::unique_future<int> f(task.get_future());
+
+        assert(f.get()==42);
+    }
+
+
+[endsect]
+
+[include future_ref.qbk]
+
+[endsect]

doc/index.html

@@ -0,0 +1,12 @@
+<!-- Copyright (c) 2002-2003 Beman Dawes, William E. Kempf.
+     Subject to the Boost Software License, Version 1.0. 
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
+-->
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../../doc/html/thread.html">
+</head>
+<body>
+Automatic redirection failed, please go to <a href="../../../doc/html/thread.html">../../../doc/html/thread.html</a>
+</body>
+</html>

doc/mutexes.qbk

@@ -0,0 +1,224 @@
+[/
+  (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
+    {
+    public:
+        mutex();
+        ~mutex();
+        
+        void lock();
+        bool try_lock();
+        void unlock();
+
+        typedef platform-specific-type native_handle_type;
+        native_handle_type native_handle();
+        
+        typedef unique_lock<mutex> scoped_lock;
+        typedef unspecified-type scoped_try_lock;
+    };
+
+__mutex__ implements the __lockable_concept__ to provide an exclusive-ownership mutex. At most one thread can own the lock on a given
+instance of __mutex__ at any time. Multiple concurrent calls to __lock_ref__, __try_lock_ref__ and __unlock_ref__ shall be permitted.
+
+[section:nativehandle Member function `native_handle()`]
+
+    typedef platform-specific-type native_handle_type;
+    native_handle_type native_handle();
+
+[variablelist
+
+[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
+implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[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.
+
+[endsect]
+
+[section:timed_mutex Class `timed_mutex`]
+
+    #include <boost/thread/mutex.hpp>
+
+    class timed_mutex:
+        boost::noncopyable
+    {
+    public:
+        timed_mutex();
+        ~timed_mutex();
+
+        void lock();
+        void unlock();
+        bool try_lock();
+        bool timed_lock(system_time const & abs_time);
+
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time);
+
+        typedef platform-specific-type native_handle_type;
+        native_handle_type native_handle();
+
+        typedef unique_lock<timed_mutex> scoped_timed_lock;
+        typedef unspecified-type scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+
+__timed_mutex__ implements the __timed_lockable_concept__ to provide an exclusive-ownership mutex. At most one thread can own the
+lock on a given instance of __timed_mutex__ at any time. Multiple concurrent calls to __lock_ref__, __try_lock_ref__,
+__timed_lock_ref__, __timed_lock_duration_ref__ and __unlock_ref__ shall be permitted.
+
+[section:nativehandle Member function `native_handle()`]
+
+    typedef platform-specific-type native_handle_type;
+    native_handle_type native_handle();
+
+[variablelist
+
+[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
+implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[endsect]
+
+[section:recursive_mutex Class `recursive_mutex`]
+
+    #include <boost/thread/recursive_mutex.hpp>
+
+    class recursive_mutex:
+        boost::noncopyable
+    {
+    public:
+        recursive_mutex();
+        ~recursive_mutex();
+        
+        void lock();
+        bool try_lock();
+        void unlock();
+
+        typedef platform-specific-type native_handle_type;
+        native_handle_type native_handle();
+        
+        typedef unique_lock<recursive_mutex> scoped_lock;
+        typedef unspecified-type scoped_try_lock;
+    };
+
+__recursive_mutex__ implements the __lockable_concept__ to provide an exclusive-ownership recursive mutex. At most one thread can
+own the lock on a given instance of __recursive_mutex__ at any time. Multiple concurrent calls to __lock_ref__, __try_lock_ref__ and
+__unlock_ref__ shall be permitted. A thread that already has exclusive ownership of a given __recursive_mutex__ instance can call
+__lock_ref__ or __try_lock_ref__ to acquire an additional level of ownership of the mutex. __unlock_ref__ must be called once for
+each level of ownership acquired by a single thread before ownership can be acquired by another thread.
+
+[section:nativehandle Member function `native_handle()`]
+
+    typedef platform-specific-type native_handle_type;
+    native_handle_type native_handle();
+
+[variablelist
+
+[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
+implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[endsect]
+
+[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.
+
+[endsect]
+
+[section:recursive_timed_mutex Class `recursive_timed_mutex`]
+
+    #include <boost/thread/recursive_mutex.hpp>
+
+    class recursive_timed_mutex:
+        boost::noncopyable
+    {
+    public:
+        recursive_timed_mutex();
+        ~recursive_timed_mutex();
+        
+        void lock();
+        bool try_lock();
+        void unlock();
+
+        bool timed_lock(system_time const & abs_time);
+
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time);
+
+        typedef platform-specific-type native_handle_type;
+        native_handle_type native_handle();
+        
+        typedef unique_lock<recursive_timed_mutex> scoped_lock;
+        typedef unspecified-type scoped_try_lock;
+        typedef scoped_lock scoped_timed_lock;
+    };
+
+__recursive_timed_mutex__ implements the __timed_lockable_concept__ to provide an exclusive-ownership recursive mutex. At most one
+thread can own the lock on a given instance of __recursive_timed_mutex__ at any time. Multiple concurrent calls to __lock_ref__,
+__try_lock_ref__, __timed_lock_ref__, __timed_lock_duration_ref__ and __unlock_ref__ shall be permitted. A thread that already has
+exclusive ownership of a given __recursive_timed_mutex__ instance can call __lock_ref__, __timed_lock_ref__,
+__timed_lock_duration_ref__ or __try_lock_ref__ to acquire an additional level of ownership of the mutex. __unlock_ref__ must be
+called once for each level of ownership acquired by a single thread before ownership can be acquired by another thread.
+
+[section:nativehandle Member function `native_handle()`]
+
+    typedef platform-specific-type native_handle_type;
+    native_handle_type native_handle();
+
+[variablelist
+
+[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
+implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[endsect]
+
+[include shared_mutex_ref.qbk]
+
+[endsect]

doc/once.qbk

@@ -0,0 +1,65 @@
+[/
+  (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
+
+Objects of type `boost::once_flag` shall be initialized with `BOOST_ONCE_INIT`:
+
+    boost::once_flag f=BOOST_ONCE_INIT;
+
+[endsect]
+
+[section:call_once Non-member function `call_once`]
+
+    #include <boost/thread/once.hpp>
+
+    template<typename Callable>
+    void call_once(once_flag& flag,Callable func);
+
+[variablelist
+
+[[Requires:] [`Callable` is `CopyConstructible`. Copying `func` shall have no side effects, and the effect of calling the copy shall
+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
+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`. ]]
+
+[[Synchronization:] [The completion of an effective `call_once` invocation on a `once_flag` object, synchronizes with
+all subsequent `call_once` invocations on the same `once_flag` object. ]]
+
+[[Throws:] [`thread_resource_error` when the effects cannot be achieved. or any exception propagated from `func`.]]
+
+[[Note:] [The function passed to `call_once` must not also call
+`call_once` passing the same `once_flag` object. This may cause
+deadlock, or invoking the passed function a second time. The
+alternative is to allow the second call to return immediately, but
+that assumes the code knows it has been called recursively, and can
+proceed even though the call to `call_once` didn't actually call the
+function, in which case it could also avoid calling `call_once`
+recursively.]]
+
+]
+
+    void call_once(void (*func)(),once_flag& flag);
+    
+This second overload is provided for backwards compatibility. The effects of `call_once(func,flag)` shall be the same as those of
+`call_once(flag,func)`.
+
+[endsect]
+[endsect]

doc/overview.qbk

@@ -0,0 +1,30 @@
+[/
+  (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
+functions for managing the threads themselves, along with others for synchronizing data between the threads or providing separate
+copies of data specific to individual threads.
+
+The __boost_thread__ library was originally written and designed by William E. Kempf. This version is a major rewrite designed to
+closely follow the proposals presented to the C++ Standards Committee, in particular
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2497.html N2497],
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2320.html N2320],
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2184.html N2184], 
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2139.html N2139], and 
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2094.html N2094]
+
+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]

doc/shared_mutex_ref.qbk

@@ -0,0 +1,44 @@
+[/
+  (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:
+        shared_mutex();
+        ~shared_mutex();
+
+        void lock_shared();
+        bool try_lock_shared();
+        bool timed_lock_shared(system_time const& timeout);
+        void unlock_shared();
+
+        void lock();
+        bool try_lock();
+        bool timed_lock(system_time const& timeout);
+        void unlock();
+
+        void lock_upgrade();
+        void unlock_upgrade();
+
+        void unlock_upgrade_and_lock();
+        void unlock_and_lock_upgrade();
+        void unlock_and_lock_shared();
+        void unlock_upgrade_and_lock_shared();
+    };
+
+The class `boost::shared_mutex` provides an implementation of a multiple-reader / single-writer mutex. It implements the
+__upgrade_lockable_concept__.
+
+Multiple concurrent calls to __lock_ref__, __try_lock_ref__, __timed_lock_ref__, __lock_shared_ref__, __try_lock_shared_ref__ and
+__timed_lock_shared_ref__ shall be permitted.
+
+
+[endsect]

doc/thread.qbk

@@ -0,0 +1,168 @@
+[/
+  (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]]
+    [copyright 2007-8 Anthony Williams]
+    [purpose C++ Library for launching threads and synchronizing data between them]
+    [category text]
+    [license
+        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])
+    ]
+]
+
+[template lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.lockable [link_text]]]
+[def __lockable_concept__ [lockable_concept_link `Lockable` concept]]
+[def __lockable_concept_type__ [lockable_concept_link `Lockable`]]
+
+[template timed_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable [link_text]]]
+[def __timed_lockable_concept__ [timed_lockable_concept_link `TimedLockable` concept]]
+[def __timed_lockable_concept_type__ [timed_lockable_concept_link `TimedLockable`]]
+
+[template shared_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable [link_text]]]
+[def __shared_lockable_concept__ [shared_lockable_concept_link `SharedLockable` concept]]
+[def __shared_lockable_concept_type__ [shared_lockable_concept_link `SharedLockable`]]
+
+[template upgrade_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable [link_text]]]
+[def __upgrade_lockable_concept__ [upgrade_lockable_concept_link `UpgradeLockable` concept]]
+[def __upgrade_lockable_concept_type__ [upgrade_lockable_concept_link `UpgradeLockable`]]
+
+
+[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()`]]
+
+[template try_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.lockable.try_lock [link_text]]]
+[def __try_lock_ref__ [try_lock_ref_link `try_lock()`]]
+
+[template timed_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock [link_text]]]
+[def __timed_lock_ref__ [timed_lock_ref_link `timed_lock()`]]
+
+[template timed_lock_duration_ref_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock_duration [link_text]]]
+[def __timed_lock_duration_ref__ [timed_lock_duration_ref_link `timed_lock()`]]
+
+[template lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.lock_shared [link_text]]]
+[def __lock_shared_ref__ [lock_shared_ref_link `lock_shared()`]]
+
+[template unlock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.unlock_shared [link_text]]]
+[def __unlock_shared_ref__ [unlock_shared_ref_link `unlock_shared()`]]
+
+[template try_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.try_lock_shared [link_text]]]
+[def __try_lock_shared_ref__ [try_lock_shared_ref_link `try_lock_shared()`]]
+
+[template timed_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.timed_lock_shared [link_text]]]
+[def __timed_lock_shared_ref__ [timed_lock_shared_ref_link `timed_lock_shared()`]]
+
+[template timed_lock_shared_duration_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.timed_lock_shared_duration [link_text]]]
+[def __timed_lock_shared_duration_ref__ [timed_lock_shared_duration_ref_link `timed_lock_shared()`]]
+
+[template lock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.lock_upgrade [link_text]]]
+[def __lock_upgrade_ref__ [lock_upgrade_ref_link `lock_upgrade()`]]
+
+[template unlock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade [link_text]]]
+[def __unlock_upgrade_ref__ [unlock_upgrade_ref_link `unlock_upgrade()`]]
+
+[template unlock_upgrade_and_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade_and_lock [link_text]]]
+[def __unlock_upgrade_and_lock_ref__ [unlock_upgrade_and_lock_ref_link `unlock_upgrade_and_lock()`]]
+
+[template unlock_and_lock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_and_lock_upgrade [link_text]]]
+[def __unlock_and_lock_upgrade_ref__ [unlock_and_lock_upgrade_ref_link `unlock_and_lock_upgrade()`]]
+
+[template unlock_upgrade_and_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade_and_lock_shared [link_text]]]
+[def __unlock_upgrade_and_lock_shared_ref__ [unlock_upgrade_and_lock_shared_ref_link `unlock_upgrade_and_lock_shared()`]]
+
+[template owns_lock_ref_link[link_text] [link thread.synchronization.locks.unique_lock.owns_lock [link_text]]]
+[def __owns_lock_ref__ [owns_lock_ref_link `owns_lock()`]]
+
+[template owns_lock_shared_ref_link[link_text] [link thread.synchronization.locks.shared_lock.owns_lock [link_text]]]
+[def __owns_lock_shared_ref__ [owns_lock_shared_ref_link `owns_lock()`]]
+
+[template mutex_func_ref_link[link_text] [link thread.synchronization.locks.unique_lock.mutex [link_text]]]
+[def __mutex_func_ref__ [mutex_func_ref_link `mutex()`]]
+
+[def __boost_thread__ [*Boost.Thread]]
+[def __not_a_thread__ ['Not-a-Thread]]
+[def __interruption_points__ [link interruption_points ['interruption points]]]
+
+[def __mutex__ [link thread.synchronization.mutex_types.mutex `boost::mutex`]]
+[def __try_mutex__ [link thread.synchronization.mutex_types.try_mutex `boost::try_mutex`]]
+[def __timed_mutex__ [link thread.synchronization.mutex_types.timed_mutex `boost::timed_mutex`]]
+[def __recursive_mutex__ [link thread.synchronization.mutex_types.recursive_mutex `boost::recursive_mutex`]]
+[def __recursive_try_mutex__ [link thread.synchronization.mutex_types.recursive_try_mutex `boost::recursive_try_mutex`]]
+[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 __shared_lock__ [link thread.synchronization.locks.shared_lock `boost::shared_lock`]]
+[def __upgrade_lock__ [link thread.synchronization.locks.upgrade_lock `boost::upgrade_lock`]]
+[def __upgrade_to_unique_lock__ [link thread.synchronization.locks.upgrade_to_unique_lock `boost::upgrade_to_unique_lock`]]
+
+
+[def __thread__ [link thread.thread_management.thread `boost::thread`]]
+[def __thread_id__ [link thread.thread_management.thread.id `boost::thread::id`]]
+[template join_link[link_text] [link thread.thread_management.thread.join [link_text]]]
+[def __join__ [join_link `join()`]]
+[template timed_join_link[link_text] [link thread.thread_management.thread.timed_join [link_text]]]
+[def __timed_join__ [timed_join_link `timed_join()`]]
+[def __detach__ [link thread.thread_management.thread.detach `detach()`]]
+[def __interrupt__ [link thread.thread_management.thread.interrupt `interrupt()`]]
+[def __sleep__ [link thread.thread_management.this_thread.sleep `boost::this_thread::sleep()`]]
+
+[def __interruption_enabled__ [link thread.thread_management.this_thread.interruption_enabled `boost::this_thread::interruption_enabled()`]]
+[def __interruption_requested__ [link thread.thread_management.this_thread.interruption_requested `boost::this_thread::interruption_requested()`]]
+[def __interruption_point__ [link thread.thread_management.this_thread.interruption_point `boost::this_thread::interruption_point()`]]
+[def __disable_interruption__ [link thread.thread_management.this_thread.disable_interruption `boost::this_thread::disable_interruption`]]
+[def __restore_interruption__ [link thread.thread_management.this_thread.restore_interruption `boost::this_thread::restore_interruption`]]
+
+[def __thread_resource_error__ `boost::thread_resource_error`]
+[def __thread_interrupted__ `boost::thread_interrupted`]
+[def __barrier__ [link thread.synchronization.barriers.barrier `boost::barrier`]]
+
+[template cond_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable.wait [link_text]]]
+[def __cond_wait__ [cond_wait_link `wait()`]]
+[template cond_timed_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable.timed_wait [link_text]]]
+[def __cond_timed_wait__ [cond_timed_wait_link `timed_wait()`]]
+[template cond_any_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable_any.wait [link_text]]]
+[def __cond_any_wait__ [cond_any_wait_link `wait()`]]
+[template cond_any_timed_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable_any.timed_wait [link_text]]]
+[def __cond_any_timed_wait__ [cond_any_timed_wait_link `timed_wait()`]]
+
+[def __blocked__ ['blocked]]
+
+[include overview.qbk]
+[include changes.qbk]
+
+[include thread_ref.qbk]
+
+[section:synchronization Synchronization]
+[include mutex_concepts.qbk]
+[include mutexes.qbk]
+[include condition_variables.qbk]
+[include once.qbk]
+[include barrier.qbk]
+[include futures.qbk]
+[endsect]
+
+[include tss.qbk]
+
+[include time.qbk]
+
+[include acknowledgements.qbk]

doc/time.qbk

@@ -0,0 +1,75 @@
+[/
+  (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
+time out. These include (but are not limited to):
+
+* __sleep__
+* __timed_join__
+* __cond_timed_wait__
+* __timed_lock_ref__
+
+For the overloads that accept an absolute time parameter, an object of type [link thread.time.system_time `boost::system_time`] is
+required. Typically, this will be obtained by adding a duration to the current time, obtained with a call to [link
+thread.time.get_system_time `boost::get_system_time()`]. e.g.
+
+    boost::system_time const timeout=boost::get_system_time() + boost::posix_time::milliseconds(500);
+
+    extern bool done;
+    extern boost::mutex m;
+    extern boost::condition_variable cond;
+
+    boost::unique_lock<boost::mutex> lk(m);
+    while(!done)
+    {
+        if(!cond.timed_wait(lk,timeout))
+        {
+            throw "timed out";
+        }
+    }
+
+For the overloads that accept a ['TimeDuration] parameter, an object of any type that meets the [link
+date_time.posix_time.time_duration Boost.Date_Time Time Duration requirements] can be used, e.g.
+
+    boost::this_thread::sleep(boost::posix_time::milliseconds(25));
+    
+    boost::mutex m;
+    if(m.timed_lock(boost::posix_time::nanoseconds(100)))
+    {
+        //  ...
+    }
+
+[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.
+
+[endsect]
+
+[section:get_system_time Non-member function `get_system_time()`]
+
+    #include <boost/thread/thread_time.hpp>
+
+    system_time get_system_time();
+
+[variablelist
+
+[[Returns:] [The current time.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[endsect]

doc/tss.qbk

@@ -0,0 +1,189 @@
+[/
+  (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]
+
+Thread local storage allows multi-threaded applications to have a separate instance of a given data item for each thread. Where a
+single-threaded application would use static or global data, this could lead to contention, deadlock or data corruption in a
+multi-threaded application. One example is the C `errno` variable, used for storing the error code related to functions from the
+Standard C library. It is common practice (and required by POSIX) for compilers that support multi-threaded applications to provide
+a separate instance of `errno` for each thread, in order to avoid different threads competing to read or update the value.
+
+Though compilers often provide this facility in the form of extensions to the declaration syntax (such as `__declspec(thread)` or
+`__thread` annotations on `static` or namespace-scope variable declarations), such support is non-portable, and is often limited in
+some way, such as only supporting POD types.
+
+[heading Portable thread-local storage with `boost::thread_specific_ptr`]
+
+`boost::thread_specific_ptr` provides a portable mechanism for thread-local storage that works on all compilers supported by
+__boost_thread__. Each instance of `boost::thread_specific_ptr` represents a pointer to an object (such as `errno`) where each
+thread must have a distinct value. The value for the current thread can be obtained using the `get()` member function, or by using
+the `*` and `->` pointer deference operators. Initially the pointer has a value of `NULL` in each thread, but the value for the
+current thread can be set using the `reset()` member function.
+
+If the value of the pointer for the current thread is changed using `reset()`, then the previous value is destroyed by calling the
+cleanup routine. Alternatively, the stored value can be reset to `NULL` and the prior value returned by calling the `release()`
+member function, allowing the application to take back responsibility for destroying the object.
+
+[heading Cleanup at thread exit]
+
+When a thread exits, the objects associated with each `boost::thread_specific_ptr` instance are destroyed. By default, the object
+pointed to by a pointer `p` is destroyed by invoking `delete p`, but this can be overridden for a specific instance of
+`boost::thread_specific_ptr` by providing a cleanup routine to the constructor. In this case, the object is destroyed by invoking
+`func(p)` where `func` is the cleanup routine supplied to the constructor. The cleanup functions are called in an unspecified
+order. If a cleanup routine sets the value of associated with an instance of `boost::thread_specific_ptr` that has already been
+cleaned up, that value is added to the cleanup list. Cleanup finishes when there are no outstanding instances of
+`boost::thread_specific_ptr` with values.
+
+Note: on some platforms, cleanup of thread-specific data is not
+performed for threads created with the platform's native API. On those
+platforms such cleanup is only done for threads that are started with
+`boost::thread` unless `boost::on_thread_exit()` is called manually
+from that thread.
+
+[section:thread_specific_ptr Class `thread_specific_ptr`]
+
+    #include <boost/thread/tss.hpp>
+
+    template <typename T>
+    class thread_specific_ptr
+    {
+    public:
+        thread_specific_ptr();
+        explicit thread_specific_ptr(void (*cleanup_function)(T*));
+        ~thread_specific_ptr();
+
+        T* get() const;
+        T* operator->() const;
+        T& operator*() const;
+
+        T* release();
+        void reset(T* new_value=0);
+    };
+
+[section:default_constructor `thread_specific_ptr();`]
+
+[variablelist
+
+[[Requires:] [`delete this->get()` is well-formed.]]
+
+[[Effects:] [Construct a `thread_specific_ptr` object for storing a pointer to an object of type `T` specific to each thread. The
+default `delete`-based cleanup function will be used to destroy any thread-local objects when `reset()` is called, or the thread
+exits.]]
+
+[[Throws:] [`boost::thread_resource_error` if an error occurs.]]
+
+]
+
+[endsect]
+
+[section:constructor_with_custom_cleanup `explicit thread_specific_ptr(void (*cleanup_function)(T*));`]
+
+[variablelist
+
+[[Requires:] [`cleanup_function(this->get())` does not throw any exceptions.]]
+
+[[Effects:] [Construct a `thread_specific_ptr` object for storing a pointer to an object of type `T` specific to each thread. The
+supplied `cleanup_function` will be used to destroy any thread-local objects when `reset()` is called, or the thread exits.]]
+
+[[Throws:] [`boost::thread_resource_error` if an error occurs.]]
+
+]
+
+[endsect]
+
+[section:destructor `~thread_specific_ptr();`]
+
+[variablelist
+
+[[Effects:] [Calls `this->reset()` to clean up the associated value for the current thread, and destroys `*this`.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[note Care needs to be taken to ensure that any threads still running after an instance of `boost::thread_specific_ptr` has been
+destroyed do not call any member functions on that instance.]
+
+[endsect]
+
+[section:get `T* get() const;`]
+
+[variablelist
+
+[[Returns:] [The pointer associated with the current thread.]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[note The initial value associated with an instance of `boost::thread_specific_ptr` is `NULL` for each thread.]
+
+[endsect]
+
+[section:operator_arrow `T* operator->() const;`]
+
+[variablelist
+
+[[Returns:] [`this->get()`]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:operator_star `T& operator*() const;`]
+
+[variablelist
+
+[[Requires:] [`this->get` is not `NULL`.]]
+
+[[Returns:] [`*(this->get())`]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+[section:reset `void reset(T* new_value=0);`]
+
+[variablelist
+
+[[Effects:] [If `this->get()!=new_value` and `this->get()` is non-`NULL`, invoke `delete this->get()` or
+`cleanup_function(this->get())` as appropriate. Store `new_value` as the pointer associated with the current thread.]]
+
+[[Postcondition:] [`this->get()==new_value`]]
+
+[[Throws:] [`boost::thread_resource_error` if an error occurs.]]
+
+]
+
+[endsect]
+
+[section:release `T* release();`]
+
+[variablelist
+
+[[Effects:] [Return `this->get()` and store `NULL` as the pointer associated with the current thread without invoking the cleanup
+function.]]
+
+[[Postcondition:] [`this->get()==0`]]
+
+[[Throws:] [Nothing.]]
+
+]
+
+[endsect]
+
+
+[endsect]
+
+[endsect]

example/Jamfile.v2

@@ -0,0 +1,23 @@
+# Copyright (C) 2001-2003
+# William E. Kempf
+#
+#  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+#  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+project boost/thread/example 
+    : requirements <library>../build//boost_thread <threading>multi
+    ;
+       
+
+exe monitor : monitor.cpp ;
+exe starvephil : starvephil.cpp ;
+exe tennis : tennis.cpp ;
+exe condition : condition.cpp ;
+exe mutex : mutex.cpp ;
+exe once : once.cpp ;
+exe recursive_mutex : recursive_mutex.cpp ;
+exe thread : thread.cpp ;
+exe thread_group : thread_group.cpp ;
+exe tss : tss.cpp ;
+exe xtime : xtime.cpp ;
+

example/condition.cpp

@@ -0,0 +1,89 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+#include <vector>
+#include <boost/utility.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
+
+class bounded_buffer : private boost::noncopyable
+{
+public:
+    typedef boost::mutex::scoped_lock lock;
+
+    bounded_buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) { }
+
+    void send (int m) {
+        lock lk(monitor);
+        while (buffered == circular_buf.size())
+            buffer_not_full.wait(lk);
+        circular_buf[end] = m;
+        end = (end+1) % circular_buf.size();
+        ++buffered;
+        buffer_not_empty.notify_one();
+    }
+    int receive() {
+        lock lk(monitor);
+        while (buffered == 0)
+            buffer_not_empty.wait(lk);
+        int i = circular_buf[begin];
+        begin = (begin+1) % circular_buf.size();
+        --buffered;
+        buffer_not_full.notify_one();
+        return i;
+    }
+
+private:
+    int begin, end, buffered;
+    std::vector<int> circular_buf;
+    boost::condition buffer_not_full, buffer_not_empty;
+    boost::mutex monitor;
+};
+
+bounded_buffer buf(2);
+
+boost::mutex io_mutex;
+
+void sender() {
+    int n = 0;
+    while (n < 1000000) {
+        buf.send(n);
+        if(!(n%10000))
+        {
+            boost::mutex::scoped_lock io_lock(io_mutex);
+            std::cout << "sent: " << n << std::endl;
+        }
+        ++n;
+    }
+    buf.send(-1);
+}
+
+void receiver() {
+    int n;
+    do {
+        n = buf.receive();
+        if(!(n%10000))
+        {
+            boost::mutex::scoped_lock io_lock(io_mutex);
+            std::cout << "received: " << n << std::endl;
+        }
+    } while (n != -1); // -1 indicates end of buffer
+    buf.send(-1);
+}
+
+int main(int, char*[])
+{
+    boost::thread thrd1(&sender);
+    boost::thread thrd2(&receiver);
+    boost::thread thrd3(&receiver);
+    boost::thread thrd4(&receiver);
+    thrd1.join();
+    thrd2.join();
+    thrd3.join();
+    thrd4.join();
+    return 0;
+}

example/monitor.cpp

@@ -0,0 +1,112 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <vector>
+#include <iostream>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/recursive_mutex.hpp>
+#include <boost/thread/thread.hpp>
+
+namespace {
+const int ITERS = 100;
+boost::mutex io_mutex;
+} // namespace
+
+template <typename M>
+class buffer_t
+{
+public:
+    typedef typename M::scoped_lock scoped_lock;
+
+    buffer_t(int n)
+        : p(0), c(0), full(0), buf(n)
+    {
+    }
+
+    void send(int m)
+    {
+        scoped_lock lk(mutex);
+        while (full == buf.size())
+            cond.wait(lk);
+        buf[p] = m;
+        p = (p+1) % buf.size();
+        ++full;
+        cond.notify_one();
+    }
+    int receive()
+    {
+        scoped_lock lk(mutex);
+        while (full == 0)
+            cond.wait(lk);
+        int i = buf[c];
+        c = (c+1) % buf.size();
+        --full;
+        cond.notify_one();
+        return i;
+    }
+
+    static buffer_t& get_buffer()
+    {
+        static buffer_t buf(2);
+        return buf;
+    }
+
+    static void do_sender_thread()
+    {
+        for (int n = 0; n < ITERS; ++n)
+        {
+            {
+                boost::mutex::scoped_lock lock(io_mutex);
+                std::cout << "sending: " << n << std::endl;
+            }
+            get_buffer().send(n);
+        }
+    }
+
+    static void do_receiver_thread()
+    {
+        for (int x=0; x < (ITERS/2); ++x)
+        {
+            int n = get_buffer().receive();
+            {
+                boost::mutex::scoped_lock lock(io_mutex);
+                std::cout << "received: " << n << std::endl;
+            }
+        }
+    }
+
+private:
+    M mutex;
+    boost::condition cond;
+    unsigned int p, c, full;
+    std::vector<int> buf;
+};
+
+template <typename M>
+void do_test(M* dummy=0)
+{
+    typedef buffer_t<M> buffer_type;
+    buffer_type::get_buffer();
+    boost::thread thrd1(&buffer_type::do_receiver_thread);
+    boost::thread thrd2(&buffer_type::do_receiver_thread);
+    boost::thread thrd3(&buffer_type::do_sender_thread);
+    thrd1.join();
+    thrd2.join();
+    thrd3.join();
+}
+
+void test_buffer()
+{
+    do_test<boost::mutex>();
+    do_test<boost::recursive_mutex>();
+}
+
+int main()
+{
+    test_buffer();
+    return 0;
+}

example/mutex.cpp

@@ -0,0 +1,47 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <iostream>
+
+boost::mutex io_mutex; // The iostreams are not guaranteed to be thread-safe!
+
+class counter
+{
+public:
+    counter() : count(0) { }
+
+    int increment() {
+        boost::mutex::scoped_lock scoped_lock(mutex);
+        return ++count;
+    }
+
+private:
+    boost::mutex mutex;
+    int count;
+};
+
+counter c;
+
+void change_count()
+{
+    int i = c.increment();
+    boost::mutex::scoped_lock scoped_lock(io_mutex);
+    std::cout << "count == " << i << std::endl;
+}
+
+int main(int, char*[])
+{
+    const int num_threads = 4;
+    boost::thread_group thrds;
+    for (int i=0; i < num_threads; ++i)
+        thrds.create_thread(&change_count);
+
+    thrds.join_all();
+
+    return 0;
+}

example/once.cpp

@@ -0,0 +1,31 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/thread.hpp>
+#include <boost/thread/once.hpp>
+#include <cassert>
+
+int value=0;
+boost::once_flag once = BOOST_ONCE_INIT;
+
+void init()
+{
+    ++value;
+}
+
+void thread_proc()
+{
+    boost::call_once(&init, once);
+}
+
+int main(int argc, char* argv[])
+{
+    boost::thread_group threads;
+    for (int i=0; i<5; ++i)
+        threads.create_thread(&thread_proc);
+    threads.join_all();
+    assert(value == 1);
+}

example/recursive_mutex.cpp

@@ -0,0 +1,49 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/recursive_mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <iostream>
+
+class counter
+{
+public:
+    counter() : count(0) { }
+
+    int add(int val) {
+        boost::recursive_mutex::scoped_lock scoped_lock(mutex);
+        count += val;
+        return count;
+    }
+    int increment() {
+        boost::recursive_mutex::scoped_lock scoped_lock(mutex);
+        return add(1);
+    }
+
+private:
+    boost::recursive_mutex mutex;
+    int count;
+};
+
+counter c;
+
+void change_count()
+{
+    std::cout << "count == " << c.increment() << std::endl;
+}
+
+int main(int, char*[])
+{
+    const int num_threads=4;
+
+    boost::thread_group threads;
+    for (int i=0; i < num_threads; ++i)
+        threads.create_thread(&change_count);
+
+    threads.join_all();
+
+    return 0;
+}

example/starvephil.cpp

@@ -0,0 +1,185 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/xtime.hpp>
+#include <iostream>
+#include <time.h>
+
+namespace
+{
+boost::mutex iomx;
+} // namespace
+
+class canteen
+{
+public:
+    canteen() : m_chickens(0) { }
+
+    void get(int id)
+    {
+        boost::mutex::scoped_lock lock(m_mutex);
+        while (m_chickens == 0)
+        {
+            {
+                boost::mutex::scoped_lock lock(iomx);
+                std::cout << "(" << clock() << ") Phil" << id <<
+                    ": wot, no chickens?  I'll WAIT ..." << std::endl;
+            }
+            m_condition.wait(lock);
+        }
+        {
+            boost::mutex::scoped_lock lock(iomx);
+            std::cout << "(" << clock() << ") Phil" << id <<
+                ": those chickens look good ... one please ..." << std::endl;
+        }
+        m_chickens--;
+    }
+    void put(int value)
+    {
+        boost::mutex::scoped_lock lock(m_mutex);
+        {
+            boost::mutex::scoped_lock lock(iomx);
+            std::cout << "(" << clock()
+                      << ") Chef: ouch ... make room ... this dish is "
+                      << "very hot ..." << std::endl;
+        }
+        boost::xtime xt;
+        boost::xtime_get(&xt, boost::TIME_UTC);
+        xt.sec += 3;
+        boost::thread::sleep(xt);
+        m_chickens += value;
+        {
+            boost::mutex::scoped_lock lock(iomx);
+            std::cout << "(" << clock() <<
+                ") Chef: more chickens ... " << m_chickens <<
+                " now available ... NOTIFYING ..." << std::endl;
+        }
+        m_condition.notify_all();
+    }
+
+private:
+    boost::mutex m_mutex;
+    boost::condition m_condition;
+    int m_chickens;
+};
+
+canteen g_canteen;
+
+void chef()
+{
+    const int chickens = 4;
+    {
+        boost::mutex::scoped_lock lock(iomx);
+        std::cout << "(" << clock() << ") Chef: starting ..." << std::endl;
+    }
+    for (;;)
+    {
+        {
+            boost::mutex::scoped_lock lock(iomx);
+            std::cout << "(" << clock() << ") Chef: cooking ..." << std::endl;
+        }
+        boost::xtime xt;
+        boost::xtime_get(&xt, boost::TIME_UTC);
+        xt.sec += 2;
+        boost::thread::sleep(xt);
+        {
+            boost::mutex::scoped_lock lock(iomx);
+            std::cout << "(" << clock() << ") Chef: " << chickens
+                      << " chickens, ready-to-go ..." << std::endl;
+        }
+        g_canteen.put(chickens);
+    }
+}
+
+struct phil
+{
+    phil(int id) : m_id(id) { }
+    void run() {
+        {
+            boost::mutex::scoped_lock lock(iomx);
+            std::cout << "(" << clock() << ") Phil" << m_id
+                      << ": starting ..." << std::endl;
+        }
+        for (;;)
+        {
+            if (m_id > 0)
+            {
+                boost::xtime xt;
+                boost::xtime_get(&xt, boost::TIME_UTC);
+                xt.sec += 3;
+                boost::thread::sleep(xt);
+            }
+            {
+                boost::mutex::scoped_lock lock(iomx);
+                std::cout << "(" << clock() << ") Phil" << m_id
+                          << ": gotta eat ..." << std::endl;
+            }
+            g_canteen.get(m_id);
+            {
+                boost::mutex::scoped_lock lock(iomx);
+                std::cout << "(" << clock() << ") Phil" << m_id
+                          << ": mmm ... that's good ..." << std::endl;
+            }
+        }
+    }
+    static void do_thread(void* param) {
+        static_cast<phil*>(param)->run();
+    }
+
+    int m_id;
+};
+
+struct thread_adapt
+{
+    thread_adapt(void (*func)(void*), void* param)
+        : _func(func), _param(param)
+    {
+    }
+    int operator()() const
+    {
+        _func(_param);
+        return 0;
+    }
+
+    void (*_func)(void*);
+    void* _param;
+};
+
+class thread_adapter
+{
+public:
+    thread_adapter(void (*func)(void*), void* param)
+        : _func(func), _param(param)
+    {
+    }
+    void operator()() const { _func(_param); }
+private:
+    void (*_func)(void*);
+    void* _param;
+};
+
+int main(int argc, char* argv[])
+{
+    boost::thread thrd_chef(&chef);
+    phil p[] = { phil(0), phil(1), phil(2), phil(3), phil(4) };
+    boost::thread thrd_phil0(thread_adapter(&phil::do_thread, &p[0]));
+    boost::thread thrd_phil1(thread_adapter(&phil::do_thread, &p[1]));
+    boost::thread thrd_phil2(thread_adapter(&phil::do_thread, &p[2]));
+    boost::thread thrd_phil3(thread_adapter(&phil::do_thread, &p[3]));
+    boost::thread thrd_phil4(thread_adapter(&phil::do_thread, &p[4]));
+
+    thrd_chef.join();
+    thrd_phil0.join();
+    thrd_phil1.join();
+    thrd_phil2.join();
+    thrd_phil3.join();
+    thrd_phil4.join();
+
+    return 0;
+}

example/tennis.cpp

@@ -0,0 +1,135 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/xtime.hpp>
+#include <iostream>
+
+#if defined(BOOST_HAS_WINTHREADS)
+#   include <windows.h>
+#   include <process.h>
+#endif
+
+enum game_state
+{
+    START,
+    PLAYER_A,
+    PLAYER_B,
+    GAME_OVER,
+    ONE_PLAYER_GONE,
+    BOTH_PLAYERS_GONE
+};
+
+int state;
+boost::mutex mutex;
+boost::condition cond;
+
+char* player_name(int state)
+{
+    if (state == PLAYER_A)
+        return "PLAYER-A";
+    if (state == PLAYER_B)
+        return "PLAYER-B";
+    throw "bad player";
+    return 0;
+}
+
+void player(void* param)
+{
+    boost::mutex::scoped_lock lock(mutex);
+
+    int active = (int)param;
+    int other = active == PLAYER_A ? PLAYER_B : PLAYER_A;
+
+    while (state < GAME_OVER)
+    {
+        std::cout << player_name(active) << ": Play." << std::endl;
+        state = other;
+        cond.notify_all();
+        do
+        {
+            cond.wait(lock);
+            if (state == other)
+            {
+                std::cout << "---" << player_name(active)
+                          << ": Spurious wakeup!" << std::endl;
+            }
+        } while (state == other);
+    }
+
+    ++state;
+    std::cout << player_name(active) << ": Gone." << std::endl;
+    cond.notify_all();
+}
+
+struct thread_adapt
+{
+    thread_adapt(void (*func)(void*), void* param)
+        : _func(func), _param(param)
+    {
+    }
+    int operator()() const
+    {
+        _func(_param);
+        return 0;
+    }
+
+    void (*_func)(void*);
+    void* _param;
+};
+
+class thread_adapter
+{
+public:
+    thread_adapter(void (*func)(void*), void* param)
+        : _func(func), _param(param)
+    {
+    }
+    void operator()() const { _func(_param); }
+private:
+    void (*_func)(void*);
+    void* _param;
+};
+
+int main(int argc, char* argv[])
+{
+    state = START;
+
+    boost::thread thrda(thread_adapter(&player, (void*)PLAYER_A));
+    boost::thread thrdb(thread_adapter(&player, (void*)PLAYER_B));
+
+    boost::xtime xt;
+    boost::xtime_get(&xt, boost::TIME_UTC);
+    xt.sec += 1;
+    boost::thread::sleep(xt);
+    {
+        boost::mutex::scoped_lock lock(mutex);
+        std::cout << "---Noise ON..." << std::endl;
+    }
+
+    for (int i = 0; i < 1000000000; ++i)
+        cond.notify_all();
+
+    {
+        boost::mutex::scoped_lock lock(mutex);
+        std::cout << "---Noise OFF..." << std::endl;
+        state = GAME_OVER;
+        cond.notify_all();
+        do
+        {
+            cond.wait(lock);
+        } while (state != BOTH_PLAYERS_GONE);
+    }
+
+    std::cout << "GAME OVER" << std::endl;
+
+    thrda.join();
+    thrdb.join();
+
+    return 0;
+}

example/thread.cpp

@@ -0,0 +1,35 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/thread.hpp>
+#include <boost/thread/xtime.hpp>
+#include <iostream>
+
+struct thread_alarm
+{
+    thread_alarm(int secs) : m_secs(secs) { }
+    void operator()()
+    {
+        boost::xtime xt;
+        boost::xtime_get(&xt, boost::TIME_UTC);
+        xt.sec += m_secs;
+
+        boost::thread::sleep(xt);
+
+        std::cout << "alarm sounded..." << std::endl;
+    }
+
+    int m_secs;
+};
+
+int main(int argc, char* argv[])
+{
+    int secs = 5;
+    std::cout << "setting alarm for 5 seconds..." << std::endl;
+    thread_alarm alarm(secs);
+    boost::thread thrd(alarm);
+    thrd.join();
+}

example/thread_group.cpp

@@ -0,0 +1,25 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/thread.hpp>
+#include <iostream>
+
+int count = 0;
+boost::mutex mutex;
+
+void increment_count()
+{
+    boost::mutex::scoped_lock lock(mutex);
+    std::cout << "count = " << ++count << std::endl;
+}
+
+int main(int argc, char* argv[])
+{
+    boost::thread_group threads;
+    for (int i = 0; i < 10; ++i)
+        threads.create_thread(&increment_count);
+    threads.join_all();
+}

example/tss.cpp

@@ -0,0 +1,36 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/thread.hpp>
+#include <boost/thread/tss.hpp>
+#include <cassert>
+
+boost::thread_specific_ptr<int> value;
+
+void increment()
+{
+    int* p = value.get();
+    ++*p;
+}
+
+void thread_proc()
+{
+    value.reset(new int(0)); // initialize the thread's storage
+    for (int i=0; i<10; ++i)
+    {
+        increment();
+        int* p = value.get();
+        assert(*p == i+1);
+    }
+}
+
+int main(int argc, char* argv[])
+{
+    boost::thread_group threads;
+    for (int i=0; i<5; ++i)
+        threads.create_thread(&thread_proc);
+    threads.join_all();
+}

example/xtime.cpp

@@ -0,0 +1,16 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/thread.hpp>
+#include <boost/thread/xtime.hpp>
+
+int main(int argc, char* argv[])
+{
+    boost::xtime xt;
+    boost::xtime_get(&xt, boost::TIME_UTC);
+    xt.sec += 1;
+    boost::thread::sleep(xt); // Sleep for 1 second
+}

include/boost/thread.hpp

@@ -0,0 +1,26 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+// (C) Copyright 2008-9 Anthony Williams
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying 
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See www.boost.org/libs/thread for documentation.
+
+#if !defined(BOOST_THREAD_WEK01082003_HPP)
+#define BOOST_THREAD_WEK01082003_HPP
+
+#include <boost/thread/thread.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/once.hpp>
+#include <boost/thread/recursive_mutex.hpp>
+#include <boost/thread/tss.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/barrier.hpp>
+#include <boost/thread/future.hpp>
+
+#endif

include/boost/thread/barrier.hpp

@@ -0,0 +1,64 @@
+// Copyright (C) 2002-2003
+// David Moore, William E. Kempf
+// Copyright (C) 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)
+
+#ifndef BOOST_BARRIER_JDM030602_HPP
+#define BOOST_BARRIER_JDM030602_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <string>
+#include <stdexcept>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+
+    class barrier
+    {
+    public:
+        barrier(unsigned int count)
+            : m_threshold(count), m_count(count), m_generation(0)
+        {
+            if (count == 0)
+                boost::throw_exception(std::invalid_argument("count cannot be zero."));
+        }
+    
+        bool wait()
+        {
+            boost::mutex::scoped_lock lock(m_mutex);
+            unsigned int gen = m_generation;
+        
+            if (--m_count == 0)
+            {
+                m_generation++;
+                m_count = m_threshold;
+                m_cond.notify_all();
+                return true;
+            }
+
+            while (gen == m_generation)
+                m_cond.wait(lock);
+            return false;
+        }
+
+    private:
+        mutex m_mutex;
+        condition_variable m_cond;
+        unsigned int m_threshold;
+        unsigned int m_count;
+        unsigned int m_generation;
+    };
+
+}   // namespace boost
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/condition.hpp

@@ -0,0 +1,16 @@
+#ifndef BOOST_THREAD_CONDITION_HPP
+#define BOOST_THREAD_CONDITION_HPP
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/condition_variable.hpp>
+
+namespace boost
+{
+    typedef condition_variable_any condition;
+}
+
+#endif

include/boost/thread/condition_variable.hpp

@@ -0,0 +1,21 @@
+#ifndef BOOST_THREAD_CONDITION_VARIABLE_HPP
+#define BOOST_THREAD_CONDITION_VARIABLE_HPP
+
+//  condition_variable.hpp
+//
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/platform.hpp>
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/condition_variable.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/condition_variable.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
+
+#endif

include/boost/thread/detail/config.hpp

@@ -0,0 +1,100 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_THREAD_CONFIG_WEK01032003_HPP
+#define BOOST_THREAD_CONFIG_WEK01032003_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#  pragma warn -8008 // Condition always true/false
+#  pragma warn -8080 // Identifier declared but never used
+#  pragma warn -8057 // Parameter never used
+#  pragma warn -8066 // Unreachable code
+#endif
+
+#include "platform.hpp"
+
+// provided for backwards compatibility, since this
+// macro was used for several releases by mistake.
+#if defined(BOOST_THREAD_DYN_DLL)
+# define BOOST_THREAD_DYN_LINK
+#endif
+
+// compatibility with the rest of Boost's auto-linking code:
+#if defined(BOOST_THREAD_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
+# undef  BOOST_THREAD_USE_LIB
+# define BOOST_THREAD_USE_DLL
+#endif
+
+#if defined(BOOST_THREAD_BUILD_DLL)   //Build dll
+#elif defined(BOOST_THREAD_BUILD_LIB) //Build lib
+#elif defined(BOOST_THREAD_USE_DLL)   //Use dll
+#elif defined(BOOST_THREAD_USE_LIB)   //Use lib
+#else //Use default
+#   if defined(BOOST_THREAD_PLATFORM_WIN32)
+#       if defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN)
+            //For compilers supporting auto-tss cleanup
+            //with Boost.Threads lib, use Boost.Threads lib
+#           define BOOST_THREAD_USE_LIB
+#       else
+            //For compilers not yet supporting auto-tss cleanup
+            //with Boost.Threads lib, use Boost.Threads dll
+#           define BOOST_THREAD_USE_DLL
+#       endif
+#   else
+#       define BOOST_THREAD_USE_LIB
+#   endif
+#endif
+
+#if defined(BOOST_HAS_DECLSPEC)
+#   if defined(BOOST_THREAD_BUILD_DLL) //Build dll
+#       define BOOST_THREAD_DECL __declspec(dllexport)
+#   elif defined(BOOST_THREAD_USE_DLL) //Use dll
+#       define BOOST_THREAD_DECL __declspec(dllimport)
+#   else
+#       define BOOST_THREAD_DECL
+#   endif
+#else
+#   define BOOST_THREAD_DECL
+#endif // BOOST_HAS_DECLSPEC
+
+//
+// Automatically link to the correct build variant where possible.
+//
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_THREAD_NO_LIB) && !defined(BOOST_THREAD_BUILD_DLL) && !defined(BOOST_THREAD_BUILD_LIB)
+//
+// Tell the autolink to link dynamically, this will get undef'ed by auto_link.hpp
+// once it's done with it: 
+//
+#if defined(BOOST_THREAD_USE_DLL)
+#   define BOOST_DYN_LINK
+#endif
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#if defined(BOOST_THREAD_LIB_NAME)
+#    define BOOST_LIB_NAME BOOST_THREAD_LIB_NAME
+#else
+#    define BOOST_LIB_NAME boost_thread
+#endif
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // BOOST_THREAD_CONFIG_WEK1032003_HPP
+
+// Change Log:
+//   22 Jan 05 Roland Schwarz (speedsnail)
+//      Usage of BOOST_HAS_DECLSPEC macro.
+//      Default again is static lib usage.
+//      BOOST_DYN_LINK only defined when autolink included.

include/boost/thread/detail/force_cast.hpp

@@ -0,0 +1,39 @@
+// Copyright (C) 2001-2003
+// Mac Murrett
+//
+// 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)
+//
+// See http://www.boost.org for most recent version including documentation.
+
+#ifndef BOOST_FORCE_CAST_MJM012402_HPP
+#define BOOST_FORCE_CAST_MJM012402_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+namespace boost {
+namespace detail {
+namespace thread {
+
+// force_cast will convert anything to anything.
+
+// general case
+template<class Return_Type, class Argument_Type>
+inline Return_Type &force_cast(Argument_Type &rSrc)
+{
+    return(*reinterpret_cast<Return_Type *>(&rSrc));
+}
+
+// specialization for const
+template<class Return_Type, class Argument_Type>
+inline const Return_Type &force_cast(const Argument_Type &rSrc)
+{
+    return(*reinterpret_cast<const Return_Type *>(&rSrc));
+}
+
+} // namespace thread
+} // namespace detail
+} // namespace boost
+
+#endif // BOOST_FORCE_CAST_MJM012402_HPP

include/boost/thread/detail/move.hpp

@@ -0,0 +1,60 @@
+// 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
+
+#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>
+
+namespace boost
+{
+    namespace detail
+    {
+        template<typename T>
+        struct thread_move_t
+        {
+            T& t;
+            explicit thread_move_t(T& t_):
+                t(t_)
+            {}
+
+            T& operator*() const
+            {
+                return t;
+            }
+
+            T* operator->() const
+            {
+                return &t;
+            }
+        private:
+            void operator=(thread_move_t&);
+        };
+    }
+
+#ifndef BOOST_NO_SFINAE
+    template<typename T>
+    typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, detail::thread_move_t<T> >::type move(T& t)
+    {
+        return detail::thread_move_t<T>(t);
+    }
+#endif
+    
+    template<typename T>
+    detail::thread_move_t<T> move(detail::thread_move_t<T> t)
+    {
+        return t;
+    }
+    
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/detail/platform.hpp

@@ -0,0 +1,71 @@
+// Copyright 2006 Roland Schwarz.
+// (C) Copyright 2007 Anthony Williams
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// This work is a reimplementation along the design and ideas
+// of William E. Kempf.
+
+#ifndef BOOST_THREAD_RS06040501_HPP
+#define BOOST_THREAD_RS06040501_HPP
+
+// fetch compiler and platform configuration
+#include <boost/config.hpp>
+
+// insist on threading support being available:
+#include <boost/config/requires_threads.hpp>
+
+// choose platform
+#if defined(linux) || defined(__linux) || defined(__linux__)
+#  define BOOST_THREAD_LINUX
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+#  define BOOST_THREAD_BSD
+#elif defined(sun) || defined(__sun)
+#  define BOOST_THREAD_SOLARIS
+#elif defined(__sgi)
+#  define BOOST_THREAD_IRIX
+#elif defined(__hpux)
+#  define BOOST_THREAD_HPUX
+#elif defined(__CYGWIN__)
+#  define BOOST_THREAD_CYGWIN
+#elif (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(BOOST_DISABLE_WIN32)
+#  define BOOST_THREAD_WIN32
+#elif defined(__BEOS__)
+#  define BOOST_THREAD_BEOS
+#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+#  define BOOST_THREAD_MACOS
+#elif defined(__IBMCPP__) || defined(_AIX)
+#  define BOOST_THREAD_AIX
+#elif defined(__amigaos__)
+#  define BOOST_THREAD_AMIGAOS
+#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
+#endif
+
+// For every supported platform add a new entry into the dispatch table below.
+// BOOST_THREAD_POSIX is tested first, so on platforms where posix and native
+// threading is available, the user may choose, by defining BOOST_THREAD_POSIX
+// in her source. If a platform is known to support pthreads and no native
+// port of boost_thread is available just specify "pthread" in the
+// dispatcher table. If there is no entry for a platform but pthreads is
+// available on the platform, pthread is choosen as default. If nothing is
+// available the preprocessor will fail with a diagnostic message.
+ 
+#if defined(BOOST_THREAD_POSIX)
+#  define BOOST_THREAD_PLATFORM_PTHREAD
+#else
+#  if defined(BOOST_THREAD_WIN32)
+#       define BOOST_THREAD_PLATFORM_WIN32
+#  elif defined(BOOST_HAS_PTHREADS)
+#       define BOOST_THREAD_PLATFORM_PTHREAD
+#  else
+#       error "Sorry, no boost threads are available for this platform."
+#  endif
+#endif
+
+#endif // BOOST_THREAD_RS06040501_HPP

include/boost/thread/detail/singleton.hpp

@@ -0,0 +1,59 @@
+// Copyright (C) 2001-2003
+// Mac Murrett
+//
+// 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)
+//
+// See http://www.boost.org for most recent version including documentation.
+
+#ifndef BOOST_SINGLETON_MJM012402_HPP
+#define BOOST_SINGLETON_MJM012402_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+namespace boost {
+namespace detail {
+namespace thread {
+
+// class singleton has the same goal as all singletons: create one instance of
+// a class on demand, then dish it out as requested.
+
+template <class T>
+class singleton : private T
+{
+private:
+    singleton();
+    ~singleton();
+
+public:
+    static T &instance();
+};
+
+
+template <class T>
+inline singleton<T>::singleton()
+{
+    /* no-op */
+}
+
+template <class T>
+inline singleton<T>::~singleton()
+{
+    /* no-op */
+}
+
+template <class T>
+/*static*/ T &singleton<T>::instance()
+{
+    // function-local static to force this to work correctly at static
+    // initialization time.
+    static singleton<T> s_oT;
+    return(s_oT);
+}
+
+} // namespace thread
+} // namespace detail
+} // namespace boost
+
+#endif // BOOST_SINGLETON_MJM012402_HPP

include/boost/thread/detail/thread.hpp

@@ -0,0 +1,532 @@
+#ifndef BOOST_THREAD_THREAD_COMMON_HPP
+#define BOOST_THREAD_THREAD_COMMON_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-10 Anthony Williams
+ 
+#include <boost/thread/exceptions.hpp>
+#ifndef BOOST_NO_IOSTREAM
+#include <ostream>
+#endif
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/xtime.hpp>
+#include <boost/thread/detail/thread_heap_alloc.hpp>
+#include <boost/utility.hpp>
+#include <boost/assert.hpp>
+#include <list>
+#include <algorithm>
+#include <boost/ref.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/bind.hpp>
+#include <stdlib.h>
+#include <memory>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+
+namespace boost
+{
+    namespace detail
+    {
+        template<typename F>
+        class thread_data:
+            public detail::thread_data_base
+        {
+        public:
+#ifndef BOOST_NO_RVALUE_REFERENCES
+            thread_data(F&& f_):
+                f(static_cast<F&&>(f_))
+            {}
+            thread_data(F& f_):
+                f(f_)
+            {}
+#else
+            thread_data(F f_):
+                f(f_)
+            {}
+            thread_data(detail::thread_move_t<F> f_):
+                f(f_)
+            {}
+#endif            
+            void run()
+            {
+                f();
+            }
+        private:
+            F f;
+
+            void operator=(thread_data&);
+            thread_data(thread_data&);
+        };
+
+        template<typename F>
+        class thread_data<boost::reference_wrapper<F> >:
+            public detail::thread_data_base
+        {
+        private:
+            F& f;
+
+            void operator=(thread_data&);
+            thread_data(thread_data&);
+        public:
+            thread_data(boost::reference_wrapper<F> f_):
+                f(f_)
+            {}
+            
+            void run()
+            {
+                f();
+            }
+        };
+
+        template<typename F>
+        class thread_data<const boost::reference_wrapper<F> >:
+            public detail::thread_data_base
+        {
+        private:
+            F& f;
+            void operator=(thread_data&);
+            thread_data(thread_data&);
+        public:
+            thread_data(const boost::reference_wrapper<F> f_):
+                f(f_)
+            {}
+            
+            void run()
+            {
+                f();
+            }
+        };
+    }
+    
+    class BOOST_THREAD_DECL thread
+    {
+    private:
+        thread(thread&);
+        thread& operator=(thread&);
+
+        void release_handle();
+        
+        detail::thread_data_ptr thread_info;
+
+        void start_thread();
+        
+        explicit thread(detail::thread_data_ptr data);
+
+        detail::thread_data_ptr get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const;
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+        template<typename F>
+        static inline detail::thread_data_ptr make_thread_info(F&& f)
+        {
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(static_cast<F&&>(f)));
+        }
+        static inline detail::thread_data_ptr make_thread_info(void (*f)())
+        {
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(static_cast<void(*&&)()>(f)));
+        }
+#else
+        template<typename F>
+        static inline detail::thread_data_ptr make_thread_info(F f)
+        {
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
+        }
+        template<typename F>
+        static inline detail::thread_data_ptr make_thread_info(boost::detail::thread_move_t<F> f)
+        {
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
+        }
+
+#endif
+        struct dummy;
+    public:
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
+        thread(const volatile thread&); 
+#endif 
+        thread();
+        ~thread();
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+#ifdef BOOST_MSVC
+        template <class F>
+        explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
+            thread_info(make_thread_info(static_cast<F&&>(f)))
+        {
+            start_thread();
+        }
+#else
+        template <class F>
+        thread(F&& f):
+            thread_info(make_thread_info(static_cast<F&&>(f)))
+        {
+            start_thread();
+        }
+#endif
+
+        thread(thread&& other)
+        {
+            thread_info.swap(other.thread_info);
+        }
+        
+        thread& operator=(thread&& other)
+        {
+            thread_info=other.thread_info;
+            other.thread_info.reset();
+            return *this;
+        }
+
+        thread&& move()
+        {
+            return static_cast<thread&&>(*this);
+        }
+        
+#else
+#ifdef BOOST_NO_SFINAE
+        template <class F>
+        explicit thread(F f):
+            thread_info(make_thread_info(f))
+        {
+            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):
+            thread_info(make_thread_info(f))
+        {
+            start_thread();
+        }
+#endif
+        
+        template <class F>
+        explicit thread(detail::thread_move_t<F> f):
+            thread_info(make_thread_info(f))
+        {
+            start_thread();
+        }
+
+        thread(detail::thread_move_t<thread> x)
+        {
+            thread_info=x->thread_info;
+            x->thread_info.reset();
+        }
+       
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
+        thread& operator=(thread x) 
+        { 
+            swap(x); 
+            return *this; 
+        } 
+#else
+        thread& operator=(detail::thread_move_t<thread> x)
+        {
+            thread new_thread(x);
+            swap(new_thread);
+            return *this;
+        }
+#endif   
+        operator detail::thread_move_t<thread>()
+        {
+            return move();
+        }
+        
+        detail::thread_move_t<thread> move()
+        {
+            detail::thread_move_t<thread> x(*this);
+            return x;
+        }
+
+#endif
+
+        template <class F,class A1>
+        thread(F f,A1 a1):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
+        {
+            start_thread();
+        }
+        template <class F,class A1,class A2>
+        thread(F f,A1 a1,A2 a2):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2)))
+        {
+            start_thread();
+        }
+
+        template <class F,class A1,class A2,class A3>
+        thread(F f,A1 a1,A2 a2,A3 a3):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3)))
+        {
+            start_thread();
+        }
+
+        template <class F,class A1,class A2,class A3,class A4>
+        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4)))
+        {
+            start_thread();
+        }
+
+        template <class F,class A1,class A2,class A3,class A4,class A5>
+        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5)))
+        {
+            start_thread();
+        }
+
+        template <class F,class A1,class A2,class A3,class A4,class A5,class A6>
+        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6)))
+        {
+            start_thread();
+        }
+
+        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
+        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7)))
+        {
+            start_thread();
+        }
+
+        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
+        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8)))
+        {
+            start_thread();
+        }
+
+        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
+        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9):
+            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8,a9)))
+        {
+            start_thread();
+        }
+
+        void swap(thread& x)
+        {
+            thread_info.swap(x.thread_info);
+        }
+
+        class id;
+        id get_id() const;
+
+
+        bool joinable() const;
+        void join();
+        bool timed_join(const system_time& wait_until);
+
+        template<typename TimeDuration>
+        inline bool timed_join(TimeDuration const& rel_time)
+        {
+            return timed_join(get_system_time()+rel_time);
+        }
+        void detach();
+
+        static unsigned hardware_concurrency();
+
+        typedef detail::thread_data_base::native_handle_type native_handle_type;
+        native_handle_type native_handle();
+
+        // backwards compatibility
+        bool operator==(const thread& other) const;
+        bool operator!=(const thread& other) const;
+
+        static inline void yield()
+        {
+            this_thread::yield();
+        }
+        
+        static inline void sleep(const system_time& xt)
+        {
+            this_thread::sleep(xt);
+        }
+
+        // extensions
+        void interrupt();
+        bool interruption_requested() const;
+    };
+
+    inline void swap(thread& lhs,thread& rhs)
+    {
+        return lhs.swap(rhs);
+    }
+    
+#ifndef BOOST_NO_RVALUE_REFERENCES
+    inline thread&& move(thread& t)
+    {
+        return static_cast<thread&&>(t);
+    }
+    inline thread&& move(thread&& t)
+    {
+        return static_cast<thread&&>(t);
+    }
+#else
+    inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
+    {
+        return t;
+    }
+#endif
+
+    namespace this_thread
+    {
+        thread::id BOOST_THREAD_DECL get_id();
+
+        void BOOST_THREAD_DECL interruption_point();
+        bool BOOST_THREAD_DECL interruption_enabled();
+        bool BOOST_THREAD_DECL interruption_requested();
+
+        inline void sleep(xtime const& abs_time)
+        {
+            sleep(system_time(abs_time));
+        }
+    }
+
+    class thread::id
+    {
+    private:
+        detail::thread_data_ptr thread_data;
+            
+        id(detail::thread_data_ptr thread_data_):
+            thread_data(thread_data_)
+        {}
+        friend class thread;
+        friend id BOOST_THREAD_DECL this_thread::get_id();
+    public:
+        id():
+            thread_data()
+        {}
+            
+        bool operator==(const id& y) const
+        {
+            return thread_data==y.thread_data;
+        }
+        
+        bool operator!=(const id& y) const
+        {
+            return thread_data!=y.thread_data;
+        }
+        
+        bool operator<(const id& y) const
+        {
+            return thread_data<y.thread_data;
+        }
+        
+        bool operator>(const id& y) const
+        {
+            return y.thread_data<thread_data;
+        }
+        
+        bool operator<=(const id& y) const
+        {
+            return !(y.thread_data<thread_data);
+        }
+        
+        bool operator>=(const id& y) const
+        {
+            return !(thread_data<y.thread_data);
+        }
+
+#ifndef BOOST_NO_IOSTREAM
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+        template<class charT, class traits>
+        friend std::basic_ostream<charT, traits>& 
+        operator<<(std::basic_ostream<charT, traits>& os, const id& x)
+        {
+            if(x.thread_data)
+            {
+                return os<<x.thread_data;
+            }
+            else
+            {
+                return os<<"{Not-any-thread}";
+            }
+        }
+#else
+        template<class charT, class traits>
+        std::basic_ostream<charT, traits>& 
+        print(std::basic_ostream<charT, traits>& os) const
+        {
+            if(thread_data)
+            {
+                return os<<thread_data;
+            }
+            else
+            {
+                return os<<"{Not-any-thread}";
+            }
+        }
+
+#endif
+#endif
+    };
+
+#if !defined(BOOST_NO_IOSTREAM) && defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    template<class charT, class traits>
+    std::basic_ostream<charT, traits>& 
+    operator<<(std::basic_ostream<charT, traits>& os, const thread::id& x)
+    {
+        return x.print(os);
+    }
+#endif
+
+    inline bool thread::operator==(const thread& other) const
+    {
+        return get_id()==other.get_id();
+    }
+    
+    inline bool thread::operator!=(const thread& other) const
+    {
+        return get_id()!=other.get_id();
+    }
+        
+    namespace detail
+    {
+        struct thread_exit_function_base
+        {
+            virtual ~thread_exit_function_base()
+            {}
+            virtual void operator()()=0;
+        };
+        
+        template<typename F>
+        struct thread_exit_function:
+            thread_exit_function_base
+        {
+            F f;
+            
+            thread_exit_function(F f_):
+                f(f_)
+            {}
+            
+            void operator()()
+            {
+                f();
+            }
+        };
+        
+        void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
+    }
+    
+    namespace this_thread
+    {
+        template<typename F>
+        void at_thread_exit(F f)
+        {
+            detail::thread_exit_function_base* const thread_exit_func=detail::heap_new<detail::thread_exit_function<F> >(f);
+            detail::add_thread_exit_function(thread_exit_func);
+        }
+    }
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/detail/thread_group.hpp

@@ -0,0 +1,108 @@
+#ifndef BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
+#define BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007-9 Anthony Williams
+
+#include <list>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/mutex.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+
+namespace boost
+{
+    class thread_group
+    {
+    private:
+        thread_group(thread_group const&);
+        thread_group& operator=(thread_group const&);        
+    public:
+        thread_group() {}
+        ~thread_group()
+        {
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                delete *it;
+            }
+        }
+
+        template<typename F>
+        thread* create_thread(F threadfunc)
+        {
+            boost::lock_guard<shared_mutex> guard(m);
+            std::auto_ptr<thread> new_thread(new thread(threadfunc));
+            threads.push_back(new_thread.get());
+            return new_thread.release();
+        }
+        
+        void add_thread(thread* thrd)
+        {
+            if(thrd)
+            {
+                boost::lock_guard<shared_mutex> guard(m);
+                threads.push_back(thrd);
+            }
+        }
+            
+        void remove_thread(thread* thrd)
+        {
+            boost::lock_guard<shared_mutex> guard(m);
+            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
+            if(it!=threads.end())
+            {
+                threads.erase(it);
+            }
+        }
+        
+        void join_all()
+        {
+            boost::shared_lock<shared_mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->join();
+            }
+        }
+        
+        void interrupt_all()
+        {
+            boost::shared_lock<shared_mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->interrupt();
+            }
+        }
+        
+        size_t size() const
+        {
+            boost::shared_lock<shared_mutex> guard(m);
+            return threads.size();
+        }
+        
+    private:
+        std::list<thread*> threads;
+        mutable shared_mutex m;
+    };
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/detail/thread_heap_alloc.hpp

@@ -0,0 +1,23 @@
+#ifndef BOOST_THREAD_THREAD_HEAP_ALLOC_HPP
+#define BOOST_THREAD_THREAD_HEAP_ALLOC_HPP
+
+//  thread_heap_alloc.hpp
+//
+//  (C) Copyright 2008 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/platform.hpp>
+
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/thread_heap_alloc.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/thread_heap_alloc.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
+
+
+#endif

include/boost/thread/detail/thread_interruption.hpp

@@ -0,0 +1,35 @@
+#ifndef BOOST_THREAD_DETAIL_THREAD_INTERRUPTION_HPP
+#define BOOST_THREAD_DETAIL_THREAD_INTERRUPTION_HPP
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007-9 Anthony Williams
+
+namespace boost
+{
+    namespace this_thread
+    {
+        class BOOST_THREAD_DECL disable_interruption
+        {
+            disable_interruption(const disable_interruption&);
+            disable_interruption& operator=(const disable_interruption&);
+            
+            bool interruption_was_enabled;
+            friend class restore_interruption;
+        public:
+            disable_interruption();
+            ~disable_interruption();
+        };
+
+        class BOOST_THREAD_DECL restore_interruption
+        {
+            restore_interruption(const restore_interruption&);
+            restore_interruption& operator=(const restore_interruption&);
+        public:
+            explicit restore_interruption(disable_interruption& d);
+            ~restore_interruption();
+        };
+    }
+}
+
+#endif

include/boost/thread/detail/tss_hooks.hpp

@@ -0,0 +1,65 @@
+// (C) Copyright Michael Glassford 2004.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_TLS_HOOKS_HPP)
+#define BOOST_TLS_HOOKS_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS)
+
+namespace boost
+{
+    BOOST_THREAD_DECL void __cdecl on_process_enter(void);
+        //Function to be called when the exe or dll
+            //that uses Boost.Threads first starts
+            //or is first loaded.
+        //Should be called only before the first call to
+            //on_thread_enter().
+        //Called automatically by Boost.Threads when
+            //a method for doing so has been discovered.
+        //May be omitted; may be called multiple times.
+
+    BOOST_THREAD_DECL void __cdecl on_process_exit(void);
+        //Function to be called when the exe or dll
+            //that uses Boost.Threads first starts
+            //or is first loaded.
+        //Should be called only after the last call to
+            //on_exit_thread().
+        //Called automatically by Boost.Threads when
+            //a method for doing so has been discovered.
+        //Must not be omitted; may be called multiple times.
+
+    BOOST_THREAD_DECL void __cdecl on_thread_enter(void);
+        //Function to be called just after a thread starts
+            //in an exe or dll that uses Boost.Threads.
+        //Must be called in the context of the thread
+            //that is starting.
+        //Called automatically by Boost.Threads when
+            //a method for doing so has been discovered.
+        //May be omitted; may be called multiple times.
+
+    BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
+        //Function to be called just be fore a thread ends
+            //in an exe or dll that uses Boost.Threads.
+        //Must be called in the context of the thread
+            //that is ending.
+        //Called automatically by Boost.Threads when
+            //a method for doing so has been discovered.
+        //Must not be omitted; may be called multiple times.
+    
+    void tss_cleanup_implemented();
+        //Dummy function used both to detect whether tss cleanup
+            //cleanup has been implemented and to force
+            //it to be linked into the Boost.Threads library.
+}
+
+#endif //defined(BOOST_HAS_WINTHREADS)
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif //!defined(BOOST_TLS_HOOKS_HPP)

include/boost/thread/exceptions.hpp

@@ -0,0 +1,182 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+// Copyright (C) 2007-9 Anthony Williams
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_THREAD_EXCEPTIONS_PDM070801_H
+#define BOOST_THREAD_EXCEPTIONS_PDM070801_H
+
+#include <boost/thread/detail/config.hpp>
+
+//  pdm: Sorry, but this class is used all over the place & I end up
+//       with recursive headers if I don't separate it
+//  wek: Not sure why recursive headers would cause compilation problems
+//       given the include guards, but regardless it makes sense to
+//       seperate this out any way.
+
+#include <string>
+#include <stdexcept>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+
+    class thread_interrupted
+    {};
+
+    class thread_exception:
+        public std::exception
+    {
+    protected:
+        thread_exception():
+            m_sys_err(0)
+        {}
+    
+        thread_exception(int sys_err_code):
+            m_sys_err(sys_err_code)
+        {}
+    
+
+    public:
+        ~thread_exception() throw()
+        {}
+    
+
+        int native_error() const
+        {
+            return m_sys_err;
+        }
+    
+
+    private:
+        int m_sys_err;
+    };
+
+    class condition_error:
+        public std::exception
+    {
+    public:
+        const char* what() const throw()
+        {
+            return "Condition error";
+        }
+    };
+    
+
+    class lock_error:
+        public thread_exception
+    {
+    public:
+        lock_error()
+        {}
+    
+        lock_error(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
+        ~lock_error() throw()
+        {}
+    
+
+        virtual const char* what() const throw()
+        {
+            return "boost::lock_error";
+        }
+    };
+
+    class thread_resource_error:
+        public thread_exception
+    {
+    public:
+        thread_resource_error()
+        {}
+    
+        thread_resource_error(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
+        ~thread_resource_error() throw()
+        {}
+    
+
+        virtual const char* what() const throw()
+        {
+            return "boost::thread_resource_error";
+        }
+    
+    };
+
+    class unsupported_thread_option:
+        public thread_exception
+    {
+    public:
+        unsupported_thread_option()
+        {}
+    
+        unsupported_thread_option(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
+        ~unsupported_thread_option() throw()
+        {}
+    
+
+        virtual const char* what() const throw()
+        {
+            return "boost::unsupported_thread_option";
+        }
+    
+    };
+
+    class invalid_thread_argument:
+        public thread_exception
+    {
+    public:
+        invalid_thread_argument()
+        {}
+    
+        invalid_thread_argument(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
+        ~invalid_thread_argument() throw()
+        {}
+    
+
+        virtual const char* what() const throw()
+        {
+            return "boost::invalid_thread_argument";
+        }
+    
+    };
+
+    class thread_permission_error:
+        public thread_exception
+    {
+    public:
+        thread_permission_error()
+        {}
+    
+        thread_permission_error(int sys_err_code):
+            thread_exception(sys_err_code)
+        {}
+    
+        ~thread_permission_error() throw()
+        {}
+    
+
+        virtual const char* what() const throw()
+        {
+            return "boost::thread_permission_error";
+        }
+    
+    };
+
+} // namespace boost
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/mutex.hpp

@@ -0,0 +1,21 @@
+#ifndef BOOST_THREAD_MUTEX_HPP
+#define BOOST_THREAD_MUTEX_HPP
+
+//  mutex.hpp
+//
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/platform.hpp>
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/mutex.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/mutex.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
+
+#endif

include/boost/thread/once.hpp

@@ -0,0 +1,33 @@
+#ifndef BOOST_THREAD_ONCE_HPP
+#define BOOST_THREAD_ONCE_HPP
+
+//  once.hpp
+//
+//  (C) Copyright 2006-7 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/platform.hpp>
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/once.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/once.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    inline void call_once(void (*func)(),once_flag& flag)
+    {
+        call_once(flag,func);
+    }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/condition_variable.hpp

@@ -0,0 +1,224 @@
+#ifndef BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_HPP
+#define BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_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-10 Anthony Williams
+
+#include "timespec.hpp"
+#include "pthread_mutex_scoped_lock.hpp"
+#include "thread_data.hpp"
+#include "condition_variable_fwd.hpp"
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace this_thread
+    {
+        void BOOST_THREAD_DECL interruption_point();
+    }
+    
+    namespace thread_cv_detail
+    {
+        template<typename MutexType>
+        struct lock_on_exit
+        {
+            MutexType* m;
+            
+            lock_on_exit():
+                m(0)
+            {}
+
+            void activate(MutexType& m_)
+            {
+                m_.unlock();
+                m=&m_;
+            }
+            ~lock_on_exit()
+            {
+                if(m)
+                {
+                    m->lock();
+                }
+           }
+        };
+    }
+    
+    inline void condition_variable::wait(unique_lock<mutex>& m)
+    {
+        int res=0;
+        {
+            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
+            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+            guard.activate(m);
+            res=pthread_cond_wait(&cond,&internal_mutex);
+        }
+        this_thread::interruption_point();
+        if(res)
+        {
+            boost::throw_exception(condition_error());
+        }
+    }
+
+    inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
+    {
+        thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
+        int cond_res;
+        {
+            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+            guard.activate(m);
+            struct timespec const timeout=detail::get_timespec(wait_until);
+            cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+        }
+        this_thread::interruption_point();
+        if(cond_res==ETIMEDOUT)
+        {
+            return false;
+        }
+        if(cond_res)
+        {
+            boost::throw_exception(condition_error());
+        }
+        return true;
+    }
+
+    inline void condition_variable::notify_one()
+    {
+        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+        BOOST_VERIFY(!pthread_cond_signal(&cond));
+    }
+        
+    inline void condition_variable::notify_all()
+    {
+        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+        BOOST_VERIFY(!pthread_cond_broadcast(&cond));
+    }
+    
+    class condition_variable_any
+    {
+        pthread_mutex_t internal_mutex;
+        pthread_cond_t cond;
+
+        condition_variable_any(condition_variable_any&);
+        condition_variable_any& operator=(condition_variable_any&);
+
+    public:
+        condition_variable_any()
+        {
+            int const res=pthread_mutex_init(&internal_mutex,NULL);
+            if(res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+                boost::throw_exception(thread_resource_error());
+            }
+        }
+        ~condition_variable_any()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+        }
+        
+        template<typename lock_type>
+        void wait(lock_type& m)
+        {
+            int res=0;
+            {
+                thread_cv_detail::lock_on_exit<lock_type> guard;
+                detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+                guard.activate(m);
+                res=pthread_cond_wait(&cond,&internal_mutex);
+            }
+            this_thread::interruption_point();
+            if(res)
+            {
+                boost::throw_exception(condition_error());
+            }
+        }
+
+        template<typename lock_type,typename predicate_type>
+        void wait(lock_type& m,predicate_type pred)
+        {
+            while(!pred()) wait(m);
+        }
+        
+        template<typename lock_type>
+        bool timed_wait(lock_type& m,boost::system_time const& wait_until)
+        {
+            struct timespec const timeout=detail::get_timespec(wait_until);
+            int res=0;
+            {
+                thread_cv_detail::lock_on_exit<lock_type> guard;
+                detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+                guard.activate(m);
+                res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+            }
+            this_thread::interruption_point();
+            if(res==ETIMEDOUT)
+            {
+                return false;
+            }
+            if(res)
+            {
+                boost::throw_exception(condition_error());
+            }
+            return true;
+        }
+        template<typename lock_type>
+        bool timed_wait(lock_type& m,xtime const& wait_until)
+        {
+            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)
+        {
+            while (!pred())
+            {
+                if(!timed_wait(m, wait_until))
+                    return pred();
+            }
+            return true;
+        }
+
+        template<typename lock_type,typename predicate_type>
+        bool timed_wait(lock_type& m,xtime const& wait_until,predicate_type pred)
+        {
+            return timed_wait(m,system_time(wait_until),pred);
+        }
+
+        template<typename lock_type,typename duration_type,typename predicate_type>
+        bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
+        {
+            return timed_wait(m,get_system_time()+wait_duration,pred);
+        }
+
+        void notify_one()
+        {
+            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
+        }
+        
+        void notify_all()
+        {
+            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+            BOOST_VERIFY(!pthread_cond_broadcast(&cond));
+        }
+    };
+
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -0,0 +1,107 @@
+#ifndef BOOST_THREAD_PTHREAD_CONDITION_VARIABLE_FWD_HPP
+#define BOOST_THREAD_PTHREAD_CONDITION_VARIABLE_FWD_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/assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <pthread.h>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <boost/thread/xtime.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class condition_variable
+    {
+    private:
+        pthread_mutex_t internal_mutex;
+        pthread_cond_t cond;
+        
+        condition_variable(condition_variable&);
+        condition_variable& operator=(condition_variable&);
+
+    public:
+        condition_variable()
+        {
+            int const res=pthread_mutex_init(&internal_mutex,NULL);
+            if(res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+                boost::throw_exception(thread_resource_error());
+            }
+        }
+        ~condition_variable()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+        }
+
+        void wait(unique_lock<mutex>& m);
+
+        template<typename predicate_type>
+        void wait(unique_lock<mutex>& m,predicate_type pred)
+        {
+            while(!pred()) wait(m);
+        }
+
+        inline bool timed_wait(unique_lock<mutex>& m,
+                               boost::system_time const& wait_until);
+        bool timed_wait(unique_lock<mutex>& m,xtime const& wait_until)
+        {
+            return timed_wait(m,system_time(wait_until));
+        }
+
+        template<typename duration_type>
+        bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration)
+        {
+            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)
+        {
+            while (!pred())
+            {
+                if(!timed_wait(m, wait_until))
+                    return pred();
+            }
+            return true;
+        }
+
+        template<typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,xtime const& wait_until,predicate_type pred)
+        {
+            return timed_wait(m,system_time(wait_until),pred);
+        }
+
+        template<typename duration_type,typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred)
+        {
+            return timed_wait(m,get_system_time()+wait_duration,pred);
+        }
+
+        typedef pthread_cond_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &cond;
+        }
+
+        void notify_one();
+        void notify_all();
+    };
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/mutex.hpp

@@ -0,0 +1,222 @@
+#ifndef BOOST_THREAD_PTHREAD_MUTEX_HPP
+#define BOOST_THREAD_PTHREAD_MUTEX_HPP
+// (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)
+
+#include <pthread.h>
+#include <boost/utility.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <boost/thread/xtime.hpp>
+#include <boost/assert.hpp>
+#include <errno.h>
+#include "timespec.hpp"
+#include "pthread_mutex_scoped_lock.hpp"
+
+#ifdef _POSIX_TIMEOUTS
+#if _POSIX_TIMEOUTS >= 0
+#define BOOST_PTHREAD_HAS_TIMEDLOCK
+#endif
+#endif
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class mutex
+    {
+    private:
+        mutex(mutex const&);
+        mutex& operator=(mutex const&);        
+        pthread_mutex_t m;
+    public:
+        mutex()
+        {
+            int const res=pthread_mutex_init(&m,NULL);
+            if(res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+        }
+        ~mutex()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+        }
+        
+        void lock()
+        {
+            int const res=pthread_mutex_lock(&m);
+            if(res)
+            {
+                boost::throw_exception(lock_error(res));
+            }
+        }
+
+        void unlock()
+        {
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+        }
+        
+        bool try_lock()
+        {
+            int const res=pthread_mutex_trylock(&m);
+            if(res && (res!=EBUSY))
+            {
+                boost::throw_exception(lock_error(res));
+            }
+            
+            return !res;
+        }
+
+        typedef pthread_mutex_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &m;
+        }
+
+        typedef unique_lock<mutex> scoped_lock;
+        typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
+    };
+
+    typedef mutex try_mutex;
+
+    class timed_mutex
+    {
+    private:
+        timed_mutex(timed_mutex const&);
+        timed_mutex& operator=(timed_mutex const&);        
+    private:
+        pthread_mutex_t m;
+#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+        pthread_cond_t cond;
+        bool is_locked;
+#endif
+    public:
+        timed_mutex()
+        {
+            int const res=pthread_mutex_init(&m,NULL);
+            if(res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                boost::throw_exception(thread_resource_error());
+            }
+            is_locked=false;
+#endif
+        }
+        ~timed_mutex()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+#endif
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time)
+        {
+            return timed_lock(get_system_time()+relative_time);
+        }
+        bool timed_lock(boost::xtime const & absolute_time)
+        {
+            return timed_lock(system_time(absolute_time));
+        }
+
+#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
+        void lock()
+        {
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
+        }
+
+        void unlock()
+        {
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+        }
+        
+        bool try_lock()
+        {
+            int const res=pthread_mutex_trylock(&m);
+            BOOST_ASSERT(!res || res==EBUSY);
+            return !res;
+        }
+        bool timed_lock(system_time const & abs_time)
+        {
+            struct timespec const timeout=detail::get_timespec(abs_time);
+            int const res=pthread_mutex_timedlock(&m,&timeout);
+            BOOST_ASSERT(!res || res==ETIMEDOUT);
+            return !res;
+        }
+
+        typedef pthread_mutex_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &m;
+        }
+
+#else
+        void lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            while(is_locked)
+            {
+                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+            }
+            is_locked=true;
+        }
+
+        void unlock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            is_locked=false;
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
+        }
+        
+        bool try_lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked)
+            {
+                return false;
+            }
+            is_locked=true;
+            return true;
+        }
+
+        bool timed_lock(system_time const & abs_time)
+        {
+            struct timespec const timeout=detail::get_timespec(abs_time);
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            while(is_locked)
+            {
+                int const cond_res=pthread_cond_timedwait(&cond,&m,&timeout);
+                if(cond_res==ETIMEDOUT)
+                {
+                    return false;
+                }
+                BOOST_ASSERT(!cond_res);
+            }
+            is_locked=true;
+            return true;
+        }
+#endif
+
+        typedef unique_lock<timed_mutex> scoped_timed_lock;
+        typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+
+#endif

include/boost/thread/pthread/once.hpp

@@ -0,0 +1,95 @@
+#ifndef BOOST_THREAD_PTHREAD_ONCE_HPP
+#define BOOST_THREAD_PTHREAD_ONCE_HPP
+
+//  once.hpp
+//
+//  (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)
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/config.hpp>
+
+#include <pthread.h>
+#include <boost/assert.hpp>
+#include "pthread_mutex_scoped_lock.hpp"
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#include <boost/cstdint.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+
+    struct once_flag
+    {
+        boost::uintmax_t epoch;
+    };
+
+    namespace detail
+    {
+        BOOST_THREAD_DECL boost::uintmax_t& get_once_per_thread_epoch();
+        BOOST_THREAD_DECL extern boost::uintmax_t once_global_epoch;
+        BOOST_THREAD_DECL extern pthread_mutex_t once_epoch_mutex;
+        BOOST_THREAD_DECL extern pthread_cond_t once_epoch_cv;
+    }
+    
+#define BOOST_ONCE_INITIAL_FLAG_VALUE 0
+#define BOOST_ONCE_INIT {BOOST_ONCE_INITIAL_FLAG_VALUE}
+
+
+    // Based on Mike Burrows fast_pthread_once algorithm as described in
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html
+    template<typename Function>
+    void call_once(once_flag& flag,Function f)
+    {
+        static boost::uintmax_t const uninitialized_flag=BOOST_ONCE_INITIAL_FLAG_VALUE;
+        static boost::uintmax_t const being_initialized=uninitialized_flag+1;
+        boost::uintmax_t const epoch=flag.epoch;
+        boost::uintmax_t& this_thread_epoch=detail::get_once_per_thread_epoch();
+        
+        if(epoch<this_thread_epoch)
+        {
+            pthread::pthread_mutex_scoped_lock lk(&detail::once_epoch_mutex);
+
+            while(flag.epoch<=being_initialized)
+            {
+                if(flag.epoch==uninitialized_flag)
+                {
+                    flag.epoch=being_initialized;
+#ifndef BOOST_NO_EXCEPTIONS
+                    try
+                    {
+#endif
+                        pthread::pthread_mutex_scoped_unlock relocker(&detail::once_epoch_mutex);
+                        f();
+#ifndef BOOST_NO_EXCEPTIONS
+                    }
+                    catch(...)
+                    {
+                        flag.epoch=uninitialized_flag;
+                        BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
+                        throw;
+                    }
+#endif
+                    flag.epoch=--detail::once_global_epoch;
+                    BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
+                }
+                else
+                {
+                    while(flag.epoch==being_initialized)
+                    {
+                        BOOST_VERIFY(!pthread_cond_wait(&detail::once_epoch_cv,&detail::once_epoch_mutex));
+                    }
+                }
+            }
+            this_thread_epoch=detail::once_global_epoch;
+        }
+    }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp

@@ -0,0 +1,64 @@
+#ifndef BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
+#define BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
+//  (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)
+
+#include <pthread.h>
+#include <boost/assert.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace pthread
+    {
+        class pthread_mutex_scoped_lock
+        {
+            pthread_mutex_t* m;
+            bool locked;
+        public:
+            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
+                m(m_),locked(true)
+            {
+                BOOST_VERIFY(!pthread_mutex_lock(m));
+            }
+            void unlock()
+            {
+                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                locked=false;
+            }
+            
+            ~pthread_mutex_scoped_lock()
+            {
+                if(locked)
+                {
+                    unlock();
+                }
+            }
+            
+        };
+
+        class pthread_mutex_scoped_unlock
+        {
+            pthread_mutex_t* m;
+        public:
+            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
+                m(m_)
+            {
+                BOOST_VERIFY(!pthread_mutex_unlock(m));
+            }
+            ~pthread_mutex_scoped_unlock()
+            {
+                BOOST_VERIFY(!pthread_mutex_lock(m));
+            }
+            
+        };
+    }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/recursive_mutex.hpp

@@ -0,0 +1,345 @@
+#ifndef BOOST_THREAD_PTHREAD_RECURSIVE_MUTEX_HPP
+#define BOOST_THREAD_PTHREAD_RECURSIVE_MUTEX_HPP
+// (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)
+
+#include <pthread.h>
+#include <boost/utility.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <boost/assert.hpp>
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+#include <boost/date_time/posix_time/conversion.hpp>
+#include <errno.h>
+#include "timespec.hpp"
+#include "pthread_mutex_scoped_lock.hpp"
+
+#ifdef _POSIX_TIMEOUTS
+#if _POSIX_TIMEOUTS >= 0
+#define BOOST_PTHREAD_HAS_TIMEDLOCK
+#endif
+#endif
+
+#if defined(BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE) && defined(BOOST_PTHREAD_HAS_TIMEDLOCK)
+#define BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+#endif
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class recursive_mutex
+    {
+    private:
+        recursive_mutex(recursive_mutex const&);
+        recursive_mutex& operator=(recursive_mutex const&);        
+        pthread_mutex_t m;
+#ifndef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
+        pthread_cond_t cond;
+        bool is_locked;
+        pthread_t owner;
+        unsigned count;
+#endif
+    public:
+        recursive_mutex()
+        {
+#ifdef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
+            pthread_mutexattr_t attr;
+            
+            int const init_attr_res=pthread_mutexattr_init(&attr);
+            if(init_attr_res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+            int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
+            if(set_attr_res)
+            {
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+                boost::throw_exception(thread_resource_error());
+            }
+            
+            int const res=pthread_mutex_init(&m,&attr);
+            if(res)
+            {
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+                boost::throw_exception(thread_resource_error());
+            }
+            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+#else
+            int const res=pthread_mutex_init(&m,NULL);
+            if(res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                boost::throw_exception(thread_resource_error());
+            }
+            is_locked=false;
+            count=0;
+#endif
+        }
+        ~recursive_mutex()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+#ifndef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+#endif
+        }
+
+#ifdef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
+        void lock()
+        {
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
+        }
+
+        void unlock()
+        {
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+        }
+        
+        bool try_lock()
+        {
+            int const res=pthread_mutex_trylock(&m);
+            BOOST_ASSERT(!res || res==EBUSY);
+            return !res;
+        }
+        typedef pthread_mutex_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &m;
+        }
+
+#else
+        void lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && pthread_equal(owner,pthread_self()))
+            {
+                ++count;
+                return;
+            }
+            
+            while(is_locked)
+            {
+                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+        }
+
+        void unlock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(!--count)
+            {
+                is_locked=false;
+            }
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
+        }
+        
+        bool try_lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && !pthread_equal(owner,pthread_self()))
+            {
+                return false;
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+            return true;
+        }
+
+#endif
+
+        typedef unique_lock<recursive_mutex> scoped_lock;
+        typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
+    };
+
+    typedef recursive_mutex recursive_try_mutex;
+
+    class recursive_timed_mutex
+    {
+    private:
+        recursive_timed_mutex(recursive_timed_mutex const&);
+        recursive_timed_mutex& operator=(recursive_timed_mutex const&);        
+    private:
+        pthread_mutex_t m;
+#ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+        pthread_cond_t cond;
+        bool is_locked;
+        pthread_t owner;
+        unsigned count;
+#endif
+    public:
+        recursive_timed_mutex()
+        {
+#ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+            pthread_mutexattr_t attr;
+            
+            int const init_attr_res=pthread_mutexattr_init(&attr);
+            if(init_attr_res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+            int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
+            if(set_attr_res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+            
+            int const res=pthread_mutex_init(&m,&attr);
+            if(res)
+            {
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+                boost::throw_exception(thread_resource_error());
+            }
+            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+#else
+            int const res=pthread_mutex_init(&m,NULL);
+            if(res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                boost::throw_exception(thread_resource_error());
+            }
+            is_locked=false;
+            count=0;
+#endif
+        }
+        ~recursive_timed_mutex()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+#ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+#endif
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time)
+        {
+            return timed_lock(get_system_time()+relative_time);
+        }
+
+#ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+        void lock()
+        {
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
+        }
+
+        void unlock()
+        {
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+        }
+        
+        bool try_lock()
+        {
+            int const res=pthread_mutex_trylock(&m);
+            BOOST_ASSERT(!res || res==EBUSY);
+            return !res;
+        }
+        bool timed_lock(system_time const & abs_time)
+        {
+            struct timespec const timeout=detail::get_timespec(abs_time);
+            int const res=pthread_mutex_timedlock(&m,&timeout);
+            BOOST_ASSERT(!res || res==ETIMEDOUT);
+            return !res;
+        }
+
+        typedef pthread_mutex_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &m;
+        }
+
+#else
+        void lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && pthread_equal(owner,pthread_self()))
+            {
+                ++count;
+                return;
+            }
+            
+            while(is_locked)
+            {
+                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+        }
+
+        void unlock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(!--count)
+            {
+                is_locked=false;
+            }
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
+        }
+        
+        bool try_lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && !pthread_equal(owner,pthread_self()))
+            {
+                return false;
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+            return true;
+        }
+
+        bool timed_lock(system_time const & abs_time)
+        {
+            struct timespec const timeout=detail::get_timespec(abs_time);
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && pthread_equal(owner,pthread_self()))
+            {
+                ++count;
+                return true;
+            }
+            while(is_locked)
+            {
+                int const cond_res=pthread_cond_timedwait(&cond,&m,&timeout);
+                if(cond_res==ETIMEDOUT)
+                {
+                    return false;
+                }
+                BOOST_ASSERT(!cond_res);
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+            return true;
+        }
+#endif
+
+        typedef unique_lock<recursive_timed_mutex> scoped_timed_lock;
+        typedef detail::try_lock_wrapper<recursive_timed_mutex> scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/shared_mutex.hpp

@@ -0,0 +1,303 @@
+#ifndef BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP
+#define BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP
+
+//  (C) Copyright 2006-8 Anthony Williams
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/detail/thread_interruption.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class shared_mutex
+    {
+    private:
+        struct state_data
+        {
+            unsigned shared_count;
+            bool exclusive;
+            bool upgrade;
+            bool exclusive_waiting_blocked;
+        };
+        
+
+
+        state_data state;
+        boost::mutex state_change;
+        boost::condition_variable shared_cond;
+        boost::condition_variable exclusive_cond;
+        boost::condition_variable upgrade_cond;
+
+        void release_waiters()
+        {
+            exclusive_cond.notify_one();
+            shared_cond.notify_all();
+        }
+        
+
+    public:
+        shared_mutex()
+        {
+            state_data state_={0,0,0,0};
+            state=state_;
+        }
+
+        ~shared_mutex()
+        {
+        }
+
+        void lock_shared()
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lk(state_change);
+                
+            while(state.exclusive || state.exclusive_waiting_blocked)
+            {
+                shared_cond.wait(lk);
+            }
+            ++state.shared_count;
+        }
+
+        bool try_lock_shared()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+                
+            if(state.exclusive || state.exclusive_waiting_blocked)
+            {
+                return false;
+            }
+            else
+            {
+                ++state.shared_count;
+                return true;
+            }
+        }
+
+        bool timed_lock_shared(system_time const& timeout)
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lk(state_change);
+                
+            while(state.exclusive || state.exclusive_waiting_blocked)
+            {
+                if(!shared_cond.timed_wait(lk,timeout))
+                {
+                    return false;
+                }
+            }
+            ++state.shared_count;
+            return true;
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock_shared(TimeDuration const & relative_time)
+        {
+            return timed_lock_shared(get_system_time()+relative_time);
+        }
+
+        void unlock_shared()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+            bool const last_reader=!--state.shared_count;
+                
+            if(last_reader)
+            {
+                if(state.upgrade)
+                {
+                    state.upgrade=false;
+                    state.exclusive=true;
+                    upgrade_cond.notify_one();
+                }
+                else
+                {
+                    state.exclusive_waiting_blocked=false;
+                }
+                release_waiters();
+            }
+        }
+
+        void lock()
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lk(state_change);
+                
+            while(state.shared_count || state.exclusive)
+            {
+                state.exclusive_waiting_blocked=true;
+                exclusive_cond.wait(lk);
+            }
+            state.exclusive=true;
+        }
+
+        bool timed_lock(system_time const& timeout)
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lk(state_change);
+
+            while(state.shared_count || state.exclusive)
+            {
+                state.exclusive_waiting_blocked=true;
+                if(!exclusive_cond.timed_wait(lk,timeout))
+                {
+                    if(state.shared_count || state.exclusive)
+                    {
+                        state.exclusive_waiting_blocked=false;
+                        exclusive_cond.notify_one();
+                        return false;
+                    }
+                    break;
+                }
+            }
+            state.exclusive=true;
+            return true;
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time)
+        {
+            return timed_lock(get_system_time()+relative_time);
+        }
+
+        bool try_lock()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+                
+            if(state.shared_count || state.exclusive)
+            {
+                return false;
+            }
+            else
+            {
+                state.exclusive=true;
+                return true;
+            }
+                
+        }
+
+        void unlock()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+            state.exclusive=false;
+            state.exclusive_waiting_blocked=false;
+            release_waiters();
+        }
+
+        void lock_upgrade()
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lk(state_change);
+            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+            {
+                shared_cond.wait(lk);
+            }
+            ++state.shared_count;
+            state.upgrade=true;
+        }
+
+        bool timed_lock_upgrade(system_time const& timeout)
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lk(state_change);
+            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+            {
+                if(!shared_cond.timed_wait(lk,timeout))
+                {
+                    if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+                    {
+                        return false;
+                    }
+                    break;
+                }
+            }
+            ++state.shared_count;
+            state.upgrade=true;
+            return true;
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock_upgrade(TimeDuration const & relative_time)
+        {
+            return timed_lock_upgrade(get_system_time()+relative_time);
+        }
+
+        bool try_lock_upgrade()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+            if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
+            {
+                return false;
+            }
+            else
+            {
+                ++state.shared_count;
+                state.upgrade=true;
+                return true;
+            }
+        }
+
+        void unlock_upgrade()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+            state.upgrade=false;
+            bool const last_reader=!--state.shared_count;
+                
+            if(last_reader)
+            {
+                state.exclusive_waiting_blocked=false;
+                release_waiters();
+            }
+        }
+
+        void unlock_upgrade_and_lock()
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lk(state_change);
+            --state.shared_count;
+            while(state.shared_count)
+            {
+                upgrade_cond.wait(lk);
+            }
+            state.upgrade=false;
+            state.exclusive=true;
+        }
+
+        void unlock_and_lock_upgrade()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+            state.exclusive=false;
+            state.upgrade=true;
+            ++state.shared_count;
+            state.exclusive_waiting_blocked=false;
+            release_waiters();
+        }
+        
+        void unlock_and_lock_shared()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+            state.exclusive=false;
+            ++state.shared_count;
+            state.exclusive_waiting_blocked=false;
+            release_waiters();
+        }
+        
+        void unlock_upgrade_and_lock_shared()
+        {
+            boost::mutex::scoped_lock lk(state_change);
+            state.upgrade=false;
+            state.exclusive_waiting_blocked=false;
+            release_waiters();
+        }
+    };
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/thread_data.hpp

@@ -0,0 +1,145 @@
+#ifndef BOOST_THREAD_PTHREAD_THREAD_DATA_HPP
+#define BOOST_THREAD_PTHREAD_THREAD_DATA_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 Anthony Williams
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/optional.hpp>
+#include <pthread.h>
+#include <boost/assert.hpp>
+#include "condition_variable_fwd.hpp"
+#include <map>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class thread;
+    
+    namespace detail
+    {
+        struct tss_cleanup_function;
+        struct thread_exit_callback_node;
+        struct tss_data_node
+        {
+            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
+            void* value;
+
+            tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
+                          void* value_):
+                func(func_),value(value_)
+            {}
+        };
+
+        struct thread_data_base;
+        typedef boost::shared_ptr<thread_data_base> thread_data_ptr;
+        
+        struct BOOST_THREAD_DECL thread_data_base:
+            enable_shared_from_this<thread_data_base>
+        {
+            thread_data_ptr self;
+            pthread_t thread_handle;
+            boost::mutex data_mutex;
+            boost::condition_variable done_condition;
+            boost::mutex sleep_mutex;
+            boost::condition_variable sleep_condition;
+            bool done;
+            bool join_started;
+            bool joined;
+            boost::detail::thread_exit_callback_node* thread_exit_callbacks;
+            std::map<void const*,boost::detail::tss_data_node> tss_data;
+            bool interrupt_enabled;
+            bool interrupt_requested;
+            pthread_mutex_t* cond_mutex;
+            pthread_cond_t* current_cond;
+
+            thread_data_base():
+                done(false),join_started(false),joined(false),
+                thread_exit_callbacks(0),
+                interrupt_enabled(true),
+                interrupt_requested(false),
+                current_cond(0)
+            {}
+            virtual ~thread_data_base();
+
+            typedef pthread_t native_handle_type;
+
+            virtual void run()=0;
+        };
+
+        BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
+
+        class interruption_checker
+        {
+            thread_data_base* const thread_info;
+            pthread_mutex_t* m;
+            bool set;
+
+            void check_for_interruption()
+            {
+                if(thread_info->interrupt_requested)
+                {
+                    thread_info->interrupt_requested=false;
+                    throw thread_interrupted();
+                }
+            }
+            
+            void operator=(interruption_checker&);
+        public:
+            explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
+                thread_info(detail::get_current_thread_data()),m(cond_mutex),
+                set(thread_info && thread_info->interrupt_enabled)
+            {
+                if(set)
+                {
+                    lock_guard<mutex> guard(thread_info->data_mutex);
+                    check_for_interruption();
+                    thread_info->cond_mutex=cond_mutex;
+                    thread_info->current_cond=cond;
+                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                }
+                else
+                {
+                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                }
+            }
+            ~interruption_checker()
+            {
+                if(set)
+                {
+                    BOOST_VERIFY(!pthread_mutex_unlock(m));
+                    lock_guard<mutex> guard(thread_info->data_mutex);
+                    thread_info->cond_mutex=NULL;
+                    thread_info->current_cond=NULL;
+                }
+                else
+                {
+                    BOOST_VERIFY(!pthread_mutex_unlock(m));
+                }
+            }
+        };
+    }
+
+    namespace this_thread
+    {
+        void BOOST_THREAD_DECL yield();
+        
+        void BOOST_THREAD_DECL sleep(system_time const& abs_time);
+        
+        template<typename TimeDuration>
+        inline void sleep(TimeDuration const& rel_time)
+        {
+            this_thread::sleep(get_system_time()+rel_time);
+        }
+    }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/thread_heap_alloc.hpp

@@ -0,0 +1,242 @@
+// 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 2008 Anthony Williams
+#ifndef THREAD_HEAP_ALLOC_PTHREAD_HPP
+#define THREAD_HEAP_ALLOC_PTHREAD_HPP
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        template<typename T>
+        inline T* heap_new()
+        {
+            return new T();
+        }
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+        template<typename T,typename A1>
+        inline T* heap_new(A1&& a1)
+        {
+            return new T(static_cast<A1&&>(a1));
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1&& a1,A2&& a2)
+        {
+            return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
+        {
+            return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
+                         static_cast<A3&&>(a3));
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
+        {
+            return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
+                         static_cast<A3&&>(a3),static_cast<A4&&>(a4));
+        }
+#else
+        template<typename T,typename A1>
+        inline T* heap_new_impl(A1 a1)
+        {
+            return new T(a1);
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new_impl(A1 a1,A2 a2)
+        {
+            return new T(a1,a2);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
+        {
+            return new T(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
+        {
+            return new T(a1,a2,a3,a4);
+        }
+
+        template<typename T,typename A1>
+        inline T* heap_new(A1 const& a1)
+        {
+            return heap_new_impl<T,A1 const&>(a1);
+        }
+        template<typename T,typename A1>
+        inline T* heap_new(A1& a1)
+        {
+            return heap_new_impl<T,A1&>(a1);
+        }
+        
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1 const& a1,A2 const& a2)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1& a1,A2 const& a2)
+        {
+            return heap_new_impl<T,A1&,A2 const&>(a1,a2);
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1 const& a1,A2& a2)
+        {
+            return heap_new_impl<T,A1 const&,A2&>(a1,a2);
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1& a1,A2& a2)
+        {
+            return heap_new_impl<T,A1&,A2&>(a1,a2);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
+        {
+            return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1& a1,A2& a2,A3& a3)
+        {
+            return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
+        }
+        
+#endif        
+        template<typename T>
+        inline void heap_delete(T* data)
+        {
+            delete data;
+        }
+
+        template<typename T>
+        struct do_heap_delete
+        {
+            void operator()(T* data) const
+            {
+                detail::heap_delete(data);
+            }
+        };
+    }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/pthread/timespec.hpp

@@ -0,0 +1,36 @@
+#ifndef BOOST_THREAD_PTHREAD_TIMESPEC_HPP
+#define BOOST_THREAD_PTHREAD_TIMESPEC_HPP
+//  (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)
+
+#include <boost/thread/thread_time.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
+#include <pthread.h>
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        inline struct timespec get_timespec(boost::system_time const& abs_time)
+        {
+            struct timespec timeout={0,0};
+            boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
+            
+            timeout.tv_sec=time_since_epoch.total_seconds();
+            timeout.tv_nsec=(long)(time_since_epoch.fractional_seconds()*(1000000000l/time_since_epoch.ticks_per_second()));
+            return timeout;
+        }
+    }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/recursive_mutex.hpp

@@ -0,0 +1,21 @@
+#ifndef BOOST_THREAD_RECURSIVE_MUTEX_HPP
+#define BOOST_THREAD_RECURSIVE_MUTEX_HPP
+
+//  recursive_mutex.hpp
+//
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/platform.hpp>
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/recursive_mutex.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/recursive_mutex.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
+
+#endif

include/boost/thread/shared_mutex.hpp

@@ -0,0 +1,21 @@
+#ifndef BOOST_THREAD_SHARED_MUTEX_HPP
+#define BOOST_THREAD_SHARED_MUTEX_HPP
+
+//  shared_mutex.hpp
+//
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/platform.hpp>
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/shared_mutex.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/shared_mutex.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
+
+#endif

include/boost/thread/thread.hpp

@@ -0,0 +1,27 @@
+#ifndef BOOST_THREAD_THREAD_HPP
+#define BOOST_THREAD_THREAD_HPP
+
+//  thread.hpp
+//
+//  (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)
+
+#include <boost/thread/detail/platform.hpp>
+
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/thread_data.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/thread_data.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
+
+#include <boost/thread/detail/thread.hpp>
+#include <boost/thread/detail/thread_interruption.hpp>
+#include <boost/thread/detail/thread_group.hpp>
+
+
+#endif

include/boost/thread/thread_time.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_THREAD_TIME_HPP
+#define BOOST_THREAD_TIME_HPP
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/date_time/time_clock.hpp>
+#include <boost/date_time/microsec_time_clock.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    typedef boost::posix_time::ptime system_time;
+    
+    inline system_time get_system_time()
+    {
+#if defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
+        return boost::date_time::microsec_clock<system_time>::universal_time();
+#else // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
+        return boost::date_time::second_clock<system_time>::universal_time();
+#endif // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
+    }
+
+    namespace detail
+    {
+        inline system_time get_system_time_sentinel()
+        {
+            return system_time(boost::posix_time::pos_infin);
+        }
+
+        inline unsigned long get_milliseconds_until(system_time const& target_time)
+        {
+            if(target_time.is_pos_infinity())
+            {
+                return ~(unsigned long)0;
+            }
+            system_time const now=get_system_time();
+            if(target_time<=now)
+            {
+                return 0;
+            }
+            return static_cast<unsigned long>((target_time-now).total_milliseconds()+1);
+        }
+
+    }
+    
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/tss.hpp

@@ -0,0 +1,113 @@
+#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:
+        typedef T element_type;
+        
+        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()
+        {
+            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,true);
+        }
+
+        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

include/boost/thread/win32/basic_recursive_mutex.hpp

@@ -0,0 +1,120 @@
+#ifndef BOOST_BASIC_RECURSIVE_MUTEX_WIN32_HPP
+#define BOOST_BASIC_RECURSIVE_MUTEX_WIN32_HPP
+
+//  basic_recursive_mutex.hpp
+//
+//  (C) Copyright 2006-8 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include "thread_primitives.hpp"
+#include "basic_timed_mutex.hpp"
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        template<typename underlying_mutex_type>
+        struct basic_recursive_mutex_impl
+        {
+            long recursion_count;
+            long locking_thread_id;
+            underlying_mutex_type mutex;
+
+            void initialize()
+            {
+                recursion_count=0;
+                locking_thread_id=0;
+                mutex.initialize();
+            }
+
+            void destroy()
+            {
+                mutex.destroy();
+            }
+
+            bool try_lock()
+            {
+                long const current_thread_id=win32::GetCurrentThreadId();
+                return try_recursive_lock(current_thread_id) || try_basic_lock(current_thread_id);
+            }
+            
+            void lock()
+            {
+                long const current_thread_id=win32::GetCurrentThreadId();
+                if(!try_recursive_lock(current_thread_id))
+                {
+                    mutex.lock();
+                    BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
+                    recursion_count=1;
+                }
+            }
+            bool timed_lock(::boost::system_time const& target)
+            {
+                long const current_thread_id=win32::GetCurrentThreadId();
+                return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
+            }
+            template<typename Duration>
+            bool timed_lock(Duration const& timeout)
+            {
+                return timed_lock(get_system_time()+timeout);
+            }
+
+            void unlock()
+            {
+                if(!--recursion_count)
+                {
+                    BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,0);
+                    mutex.unlock();
+                }
+            }
+
+        private:
+            bool try_recursive_lock(long current_thread_id)
+            {
+                if(::boost::detail::interlocked_read_acquire(&locking_thread_id)==current_thread_id)
+                {
+                    ++recursion_count;
+                    return true;
+                }
+                return false;
+            }
+            
+            bool try_basic_lock(long current_thread_id)
+            {
+                if(mutex.try_lock())
+                {
+                    BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
+                    recursion_count=1;
+                    return true;
+                }
+                return false;
+            }
+            
+            bool try_timed_lock(long current_thread_id,::boost::system_time const& target)
+            {
+                if(mutex.timed_lock(target))
+                {
+                    BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,current_thread_id);
+                    recursion_count=1;
+                    return true;
+                }
+                return false;
+            }
+            
+        };
+
+        typedef basic_recursive_mutex_impl<basic_timed_mutex> basic_recursive_mutex;
+        typedef basic_recursive_mutex_impl<basic_timed_mutex> basic_recursive_timed_mutex;
+    }
+}
+
+#define BOOST_BASIC_RECURSIVE_MUTEX_INITIALIZER {0}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/basic_timed_mutex.hpp

@@ -0,0 +1,209 @@
+#ifndef BOOST_BASIC_TIMED_MUTEX_WIN32_HPP
+#define BOOST_BASIC_TIMED_MUTEX_WIN32_HPP
+
+//  basic_timed_mutex_win32.hpp
+//
+//  (C) Copyright 2006-8 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/assert.hpp>
+#include "thread_primitives.hpp"
+#include "interlocked_read.hpp"
+#include <boost/thread/thread_time.hpp>
+#include <boost/thread/xtime.hpp>
+#include <boost/detail/interlocked.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        struct basic_timed_mutex
+        {
+            BOOST_STATIC_CONSTANT(unsigned char,lock_flag_bit=31);
+            BOOST_STATIC_CONSTANT(unsigned char,event_set_flag_bit=30);
+            BOOST_STATIC_CONSTANT(long,lock_flag_value=1<<lock_flag_bit);
+            BOOST_STATIC_CONSTANT(long,event_set_flag_value=1<<event_set_flag_bit);
+            long active_count;
+            void* event;
+
+            void initialize()
+            {
+                active_count=0;
+                event=0;
+            }
+
+            void destroy()
+            {
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4312)
+#endif
+                void* const old_event=BOOST_INTERLOCKED_EXCHANGE_POINTER(&event,0);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+                if(old_event)
+                {
+                    win32::CloseHandle(old_event);
+                }
+            }
+            
+          
+            bool try_lock()
+            {
+                return !win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit);
+            }
+            
+            void lock()
+            {
+                if(try_lock())
+                {
+                    return;
+                }
+                long old_count=active_count;
+                mark_waiting_and_try_lock(old_count);
+
+                if(old_count&lock_flag_value)
+                {
+                    bool lock_acquired=false;
+                    void* const sem=get_event();
+
+                    do
+                    {
+                        BOOST_VERIFY(win32::WaitForSingleObject(
+                                         sem,::boost::detail::win32::infinite)==0);
+                        clear_waiting_and_try_lock(old_count);
+                        lock_acquired=!(old_count&lock_flag_value);
+                    }
+                    while(!lock_acquired);
+                }
+            }
+            void mark_waiting_and_try_lock(long& old_count)
+            {
+                for(;;)
+                {
+                    long const new_count=(old_count&lock_flag_value)?(old_count+1):(old_count|lock_flag_value);
+                    long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
+                    if(current==old_count)
+                    {
+                        break;
+                    }
+                    old_count=current;
+                }
+            }
+
+            void clear_waiting_and_try_lock(long& old_count)
+            {
+                old_count&=~lock_flag_value;
+                old_count|=event_set_flag_value;
+                for(;;)
+                {
+                    long const new_count=((old_count&lock_flag_value)?old_count:((old_count-1)|lock_flag_value))&~event_set_flag_value;
+                    long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
+                    if(current==old_count)
+                    {
+                        break;
+                    }
+                    old_count=current;
+                }
+            }
+            
+            
+            bool timed_lock(::boost::system_time const& wait_until)
+            {
+                if(try_lock())
+                {
+                    return true;
+                }
+                long old_count=active_count;
+                mark_waiting_and_try_lock(old_count);
+
+                if(old_count&lock_flag_value)
+                {
+                    bool lock_acquired=false;
+                    void* const sem=get_event();
+
+                    do
+                    {
+                        if(win32::WaitForSingleObject(sem,::boost::detail::get_milliseconds_until(wait_until))!=0)
+                        {
+                            BOOST_INTERLOCKED_DECREMENT(&active_count);
+                            return false;
+                        }
+                        clear_waiting_and_try_lock(old_count);
+                        lock_acquired=!(old_count&lock_flag_value);
+                    }
+                    while(!lock_acquired);
+                }
+                return true;
+            }
+
+            template<typename Duration>
+            bool timed_lock(Duration const& timeout)
+            {
+                return timed_lock(get_system_time()+timeout);
+            }
+
+            bool timed_lock(boost::xtime const& timeout)
+            {
+                return timed_lock(system_time(timeout));
+            }
+
+            void unlock()
+            {
+                long const offset=lock_flag_value;
+                long const old_count=BOOST_INTERLOCKED_EXCHANGE_ADD(&active_count,lock_flag_value);
+                if(!(old_count&event_set_flag_value) && (old_count>offset))
+                {
+                    if(!win32::interlocked_bit_test_and_set(&active_count,event_set_flag_bit))
+                    {
+                        win32::SetEvent(get_event());
+                    }
+                }
+            }
+
+        private:
+            void* get_event()
+            {
+                void* current_event=::boost::detail::interlocked_read_acquire(&event);
+                
+                if(!current_event)
+                {
+                    void* const new_event=win32::create_anonymous_event(win32::auto_reset_event,win32::event_initially_reset);
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4311)
+#pragma warning(disable:4312)
+#endif
+                    void* const old_event=BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&event,new_event,0);
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+                    if(old_event!=0)
+                    {
+                        win32::CloseHandle(new_event);
+                        return old_event;
+                    }
+                    else
+                    {
+                        return new_event;
+                    }
+                }
+                return current_event;
+            }
+            
+        };
+        
+    }
+}
+
+#define BOOST_BASIC_TIMED_MUTEX_INITIALIZER {0}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/condition_variable.hpp

@@ -0,0 +1,418 @@
+#ifndef BOOST_THREAD_CONDITION_VARIABLE_WIN32_HPP
+#define BOOST_THREAD_CONDITION_VARIABLE_WIN32_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/mutex.hpp>
+#include "thread_primitives.hpp"
+#include <limits.h>
+#include <boost/assert.hpp>
+#include <algorithm>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/thread_time.hpp>
+#include "interlocked_read.hpp"
+#include <boost/thread/xtime.hpp>
+#include <vector>
+#include <boost/intrusive_ptr.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        class basic_cv_list_entry;
+        void intrusive_ptr_add_ref(basic_cv_list_entry * p);
+        void intrusive_ptr_release(basic_cv_list_entry * p);
+        
+        class basic_cv_list_entry
+        {
+        private:
+            detail::win32::handle_manager semaphore;
+            detail::win32::handle_manager wake_sem;
+            long waiters;
+            bool notified;
+            long references;
+
+            basic_cv_list_entry(basic_cv_list_entry&);
+            void operator=(basic_cv_list_entry&);
+            
+        public:
+            explicit basic_cv_list_entry(detail::win32::handle_manager const& wake_sem_):
+                semaphore(detail::win32::create_anonymous_semaphore(0,LONG_MAX)),
+                wake_sem(wake_sem_.duplicate()),
+                waiters(1),notified(false),references(0)
+            {}
+
+            static bool no_waiters(boost::intrusive_ptr<basic_cv_list_entry> const& entry)
+            {
+                return !detail::interlocked_read_acquire(&entry->waiters);
+            }
+
+            void add_waiter()
+            {
+                BOOST_INTERLOCKED_INCREMENT(&waiters);
+            }
+            
+            void remove_waiter()
+            {
+                BOOST_INTERLOCKED_DECREMENT(&waiters);
+            }
+
+            void release(unsigned count_to_release)
+            {
+                notified=true;
+                detail::win32::ReleaseSemaphore(semaphore,count_to_release,0);
+            }
+
+            void release_waiters()
+            {
+                release(detail::interlocked_read_acquire(&waiters));
+            }
+
+            bool is_notified() const
+            {
+                return notified;
+            }
+
+            bool wait(timeout wait_until)
+            {
+                return this_thread::interruptible_wait(semaphore,wait_until);
+            }
+
+            bool woken()
+            {
+                unsigned long const woken_result=detail::win32::WaitForSingleObject(wake_sem,0);
+                BOOST_ASSERT((woken_result==detail::win32::timeout) || (woken_result==0));
+                return woken_result==0;
+            }
+
+            friend void intrusive_ptr_add_ref(basic_cv_list_entry * p);
+            friend void intrusive_ptr_release(basic_cv_list_entry * p);
+        };
+
+        inline void intrusive_ptr_add_ref(basic_cv_list_entry * p)
+        {
+            BOOST_INTERLOCKED_INCREMENT(&p->references);
+        }
+            
+        inline void intrusive_ptr_release(basic_cv_list_entry * p)
+        {
+            if(!BOOST_INTERLOCKED_DECREMENT(&p->references))
+            {
+                delete p;
+            }
+        }
+
+        class basic_condition_variable
+        {
+            boost::mutex internal_mutex;
+            long total_count;
+            unsigned active_generation_count;
+
+            typedef basic_cv_list_entry list_entry;
+
+            typedef boost::intrusive_ptr<list_entry> entry_ptr;
+            typedef std::vector<entry_ptr> generation_list;
+
+            generation_list generations;
+            detail::win32::handle_manager wake_sem;
+
+            void wake_waiters(long count_to_wake)
+            {
+                detail::interlocked_write_release(&total_count,total_count-count_to_wake);
+                detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
+            }
+            
+            template<typename lock_type>
+            struct relocker
+            {
+                lock_type& lock;
+                bool unlocked;
+                
+                relocker(lock_type& lock_):
+                    lock(lock_),unlocked(false)
+                {}
+                void unlock()
+                {
+                    lock.unlock();
+                    unlocked=true;
+                }
+                ~relocker()
+                {
+                    if(unlocked)
+                    {
+                        lock.lock();
+                    }
+                    
+                }
+            private:
+                relocker(relocker&);
+                void operator=(relocker&);
+            };
+            
+
+            entry_ptr get_wait_entry()
+            {
+                boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
+
+                if(!wake_sem)
+                {
+                    wake_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+                    BOOST_ASSERT(wake_sem);
+                }
+
+                detail::interlocked_write_release(&total_count,total_count+1);
+                if(generations.empty() || generations.back()->is_notified())
+                {
+                    entry_ptr new_entry(new list_entry(wake_sem));
+                    generations.push_back(new_entry);
+                    return new_entry;
+                }
+                else
+                {
+                    generations.back()->add_waiter();
+                    return generations.back();
+                }
+            }
+            
+            struct entry_manager
+            {
+                entry_ptr const entry;
+                    
+                entry_manager(entry_ptr const& entry_):
+                    entry(entry_)
+                {}
+                    
+                ~entry_manager()
+                {
+                    entry->remove_waiter();
+                }
+
+                list_entry* operator->()
+                {
+                    return entry.get();
+                }
+
+            private:
+                void operator=(entry_manager&);
+                entry_manager(entry_manager&);
+            };
+                
+
+        protected:
+            template<typename lock_type>
+            bool do_wait(lock_type& lock,timeout wait_until)
+            {
+                relocker<lock_type> locker(lock);
+                
+                entry_manager entry(get_wait_entry());
+
+                locker.unlock();
+
+                bool woken=false;
+                while(!woken)
+                {
+                    if(!entry->wait(wait_until))
+                    {
+                        return false;
+                    }
+                
+                    woken=entry->woken();
+                }
+                return woken;
+            }
+
+            template<typename lock_type,typename predicate_type>
+            bool do_wait(lock_type& m,timeout const& wait_until,predicate_type pred)
+            {
+                while (!pred())
+                {
+                    if(!do_wait(m, wait_until))
+                        return pred();
+                }
+                return true;
+            }
+        
+            basic_condition_variable(const basic_condition_variable& other);
+            basic_condition_variable& operator=(const basic_condition_variable& other);
+
+        public:
+            basic_condition_variable():
+                total_count(0),active_generation_count(0),wake_sem(0)
+            {}
+            
+            ~basic_condition_variable()
+            {}
+
+            void notify_one()
+            {
+                if(detail::interlocked_read_acquire(&total_count))
+                {
+                    boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
+                    if(!total_count)
+                    {
+                        return;
+                    }
+                    wake_waiters(1);
+
+                    for(generation_list::iterator it=generations.begin(),
+                            end=generations.end();
+                        it!=end;++it)
+                    {
+                        (*it)->release(1);
+                    }
+                    generations.erase(std::remove_if(generations.begin(),generations.end(),&basic_cv_list_entry::no_waiters),generations.end());
+                }
+            }
+        
+            void notify_all()
+            {
+                if(detail::interlocked_read_acquire(&total_count))
+                {
+                    boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
+                    if(!total_count)
+                    {
+                        return;
+                    }
+                    wake_waiters(total_count);
+                    for(generation_list::iterator it=generations.begin(),
+                            end=generations.end();
+                        it!=end;++it)
+                    {
+                        (*it)->release_waiters();
+                    }
+                    generations.clear();
+                    wake_sem=detail::win32::handle(0);
+                }
+            }
+        
+        };
+    }
+
+    class condition_variable:
+        private detail::basic_condition_variable
+    {
+    private:
+        condition_variable(condition_variable&);
+        void operator=(condition_variable&);
+    public:
+        condition_variable()
+        {}
+        
+        using detail::basic_condition_variable::notify_one;
+        using detail::basic_condition_variable::notify_all;
+        
+        void wait(unique_lock<mutex>& m)
+        {
+            do_wait(m,detail::timeout::sentinel());
+        }
+
+        template<typename predicate_type>
+        void wait(unique_lock<mutex>& m,predicate_type pred)
+        {
+            while(!pred()) wait(m);
+        }
+        
+
+        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
+        {
+            return do_wait(m,wait_until);
+        }
+
+        bool timed_wait(unique_lock<mutex>& m,boost::xtime const& wait_until)
+        {
+            return do_wait(m,system_time(wait_until));
+        }
+        template<typename duration_type>
+        bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration)
+        {
+            return do_wait(m,wait_duration.total_milliseconds());
+        }
+
+        template<typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until,predicate_type pred)
+        {
+            return do_wait(m,wait_until,pred);
+        }
+        template<typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,boost::xtime const& wait_until,predicate_type pred)
+        {
+            return do_wait(m,system_time(wait_until),pred);
+        }
+        template<typename duration_type,typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred)
+        {
+            return do_wait(m,wait_duration.total_milliseconds(),pred);
+        }
+    };
+    
+    class condition_variable_any:
+        private detail::basic_condition_variable
+    {
+    private:
+        condition_variable_any(condition_variable_any&);
+        void operator=(condition_variable_any&);
+    public:
+        condition_variable_any()
+        {}
+        
+        using detail::basic_condition_variable::notify_one;
+        using detail::basic_condition_variable::notify_all;
+        
+        template<typename lock_type>
+        void wait(lock_type& m)
+        {
+            do_wait(m,detail::timeout::sentinel());
+        }
+
+        template<typename lock_type,typename predicate_type>
+        void wait(lock_type& m,predicate_type pred)
+        {
+            while(!pred()) wait(m);
+        }
+        
+        template<typename lock_type>
+        bool timed_wait(lock_type& m,boost::system_time const& wait_until)
+        {
+            return do_wait(m,wait_until);
+        }
+
+        template<typename lock_type>
+        bool timed_wait(lock_type& m,boost::xtime const& wait_until)
+        {
+            return do_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 do_wait(m,wait_duration.total_milliseconds());
+        }
+
+        template<typename lock_type,typename predicate_type>
+        bool timed_wait(lock_type& m,boost::system_time const& wait_until,predicate_type pred)
+        {
+            return do_wait(m,wait_until,pred);
+        }
+
+        template<typename lock_type,typename predicate_type>
+        bool timed_wait(lock_type& m,boost::xtime const& wait_until,predicate_type pred)
+        {
+            return do_wait(m,system_time(wait_until),pred);
+        }
+
+        template<typename lock_type,typename duration_type,typename predicate_type>
+        bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
+        {
+            return do_wait(m,wait_duration.total_milliseconds(),pred);
+        }
+    };
+
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/interlocked_read.hpp

@@ -0,0 +1,80 @@
+#ifndef BOOST_THREAD_DETAIL_INTERLOCKED_READ_WIN32_HPP
+#define BOOST_THREAD_DETAIL_INTERLOCKED_READ_WIN32_HPP
+
+//  interlocked_read_win32.hpp
+//
+//  (C) Copyright 2005-8 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/detail/interlocked.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+#ifdef BOOST_MSVC
+
+extern "C" void _ReadWriteBarrier(void);
+#pragma intrinsic(_ReadWriteBarrier)
+
+namespace boost
+{
+    namespace detail
+    {
+        inline long interlocked_read_acquire(long volatile* x)
+        {
+            long const res=*x;
+            _ReadWriteBarrier();
+            return res;
+        }
+        inline void* interlocked_read_acquire(void* volatile* x)
+        {
+            void* const res=*x;
+            _ReadWriteBarrier();
+            return res;
+        }
+
+        inline void interlocked_write_release(long volatile* x,long value)
+        {
+            _ReadWriteBarrier();
+            *x=value;
+        }
+        inline void interlocked_write_release(void* volatile* x,void* value)
+        {
+            _ReadWriteBarrier();
+            *x=value;
+        }
+    }
+}
+
+#else
+
+namespace boost
+{
+    namespace detail
+    {
+        inline long interlocked_read_acquire(long volatile* x)
+        {
+            return BOOST_INTERLOCKED_COMPARE_EXCHANGE(x,0,0);
+        }
+        inline void* interlocked_read_acquire(void* volatile* x)
+        {
+            return BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(x,0,0);
+        }
+        inline void interlocked_write_release(long volatile* x,long value)
+        {
+            BOOST_INTERLOCKED_EXCHANGE(x,value);
+        }
+        inline void interlocked_write_release(void* volatile* x,void* value)
+        {
+            BOOST_INTERLOCKED_EXCHANGE_POINTER(x,value);
+        }
+    }
+}
+
+#endif
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/mutex.hpp

@@ -0,0 +1,69 @@
+#ifndef BOOST_THREAD_WIN32_MUTEX_HPP
+#define BOOST_THREAD_WIN32_MUTEX_HPP
+// (C) Copyright 2005-7 Anthony Williams
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include "basic_timed_mutex.hpp"
+#include <boost/utility.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <boost/thread/locks.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        typedef ::boost::detail::basic_timed_mutex underlying_mutex;
+    }
+
+    class mutex:
+        public ::boost::detail::underlying_mutex
+    {
+    private:
+        mutex(mutex const&);
+        mutex& operator=(mutex const&);
+    public:
+        mutex()
+        {
+            initialize();
+        }
+        ~mutex()
+        {
+            destroy();
+        }
+
+        typedef unique_lock<mutex> scoped_lock;
+        typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
+    };
+
+    typedef mutex try_mutex;
+
+    class timed_mutex:
+        public ::boost::detail::basic_timed_mutex
+    {
+    private:
+        timed_mutex(timed_mutex const&);
+        timed_mutex& operator=(timed_mutex const&);
+    public:
+        timed_mutex()
+        {
+            initialize();
+        }
+
+        ~timed_mutex()
+        {
+            destroy();
+        }
+
+        typedef unique_lock<timed_mutex> scoped_timed_lock;
+        typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/once.hpp

@@ -0,0 +1,205 @@
+#ifndef BOOST_THREAD_WIN32_ONCE_HPP
+#define BOOST_THREAD_WIN32_ONCE_HPP
+
+//  once.hpp
+//
+//  (C) Copyright 2005-7 Anthony Williams 
+//  (C) Copyright 2005 John Maddock
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstring>
+#include <cstddef>
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/detail/interlocked.hpp>
+#include <boost/thread/win32/thread_primitives.hpp>
+#include <boost/thread/win32/interlocked_read.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std
+{
+    using ::memcpy;
+    using ::ptrdiff_t;
+}
+#endif
+
+namespace boost
+{
+    struct once_flag
+    {
+        long status;
+        long count;
+    };
+
+#define BOOST_ONCE_INIT {0,0}
+
+    namespace detail
+    {
+#ifdef BOOST_NO_ANSI_APIS
+        typedef wchar_t once_char_type;
+#else
+        typedef char once_char_type;
+#endif
+        unsigned const once_mutex_name_fixed_length=54;
+        unsigned const once_mutex_name_length=once_mutex_name_fixed_length+
+            sizeof(void*)*2+sizeof(unsigned long)*2+1;
+
+        template <class I>
+        void int_to_string(I p, once_char_type* buf)
+        {
+            for(unsigned i=0; i < sizeof(I)*2; ++i,++buf)
+            {
+#ifdef BOOST_NO_ANSI_APIS
+                once_char_type const a=L'A';
+#else
+                once_char_type const a='A';
+#endif
+                *buf = a + static_cast<once_char_type>((p >> (i*4)) & 0x0f);
+            }
+            *buf = 0;
+        }
+
+        inline void name_once_mutex(once_char_type* mutex_name,void* flag_address)
+        {
+#ifdef BOOST_NO_ANSI_APIS
+            static const once_char_type fixed_mutex_name[]=L"Local\\{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+#else
+            static const once_char_type fixed_mutex_name[]="Local\\{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+#endif
+            BOOST_STATIC_ASSERT(sizeof(fixed_mutex_name) == 
+                                (sizeof(once_char_type)*(once_mutex_name_fixed_length+1)));
+            
+            std::memcpy(mutex_name,fixed_mutex_name,sizeof(fixed_mutex_name));
+            detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address), 
+                                  mutex_name + once_mutex_name_fixed_length);
+            detail::int_to_string(win32::GetCurrentProcessId(), 
+                                  mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
+        }
+                        
+        inline void* open_once_event(once_char_type* mutex_name,void* flag_address)
+        {
+            if(!*mutex_name)
+            {
+                name_once_mutex(mutex_name,flag_address);
+            }
+            
+#ifdef BOOST_NO_ANSI_APIS                        
+            return ::boost::detail::win32::OpenEventW(
+#else
+            return ::boost::detail::win32::OpenEventA(
+#endif
+                ::boost::detail::win32::synchronize | 
+                ::boost::detail::win32::event_modify_state,
+                false,
+                mutex_name);
+        }
+
+        inline void* create_once_event(once_char_type* mutex_name,void* flag_address)
+        {
+            if(!*mutex_name)
+            {
+                name_once_mutex(mutex_name,flag_address);
+            }
+#ifdef BOOST_NO_ANSI_APIS                        
+            return ::boost::detail::win32::CreateEventW(
+#else
+            return ::boost::detail::win32::CreateEventA(
+#endif
+                0,::boost::detail::win32::manual_reset_event,
+                ::boost::detail::win32::event_initially_reset,
+                mutex_name);
+        }
+    }
+    
+
+    template<typename Function>
+    void call_once(once_flag& flag,Function f)
+    {
+        // Try for a quick win: if the procedure has already been called
+        // just skip through:
+        long const function_complete_flag_value=0xc15730e2;
+        long const running_value=0x7f0725e3;
+        long status;
+        bool counted=false;
+        detail::win32::handle_manager event_handle;
+        detail::once_char_type mutex_name[detail::once_mutex_name_length];
+        mutex_name[0]=0;
+
+        while((status=::boost::detail::interlocked_read_acquire(&flag.status))
+              !=function_complete_flag_value)
+        {
+            status=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&flag.status,running_value,0);
+            if(!status)
+            {
+                try
+                {
+                    if(!event_handle)
+                    {
+                        event_handle=detail::open_once_event(mutex_name,&flag);
+                    }
+                    if(event_handle)
+                    {
+                        ::boost::detail::win32::ResetEvent(event_handle);
+                    }
+                    f();
+                    if(!counted)
+                    {
+                        BOOST_INTERLOCKED_INCREMENT(&flag.count);
+                        counted=true;
+                    }
+                    BOOST_INTERLOCKED_EXCHANGE(&flag.status,function_complete_flag_value);
+                    if(!event_handle && 
+                       (::boost::detail::interlocked_read_acquire(&flag.count)>1))
+                    {
+                        event_handle=detail::create_once_event(mutex_name,&flag);
+                    }
+                    if(event_handle)
+                    {
+                        ::boost::detail::win32::SetEvent(event_handle);
+                    }
+                    break;
+                }
+                catch(...)
+                {
+                    BOOST_INTERLOCKED_EXCHANGE(&flag.status,0);
+                    if(!event_handle)
+                    {
+                        event_handle=detail::open_once_event(mutex_name,&flag);
+                    }
+                    if(event_handle)
+                    {
+                        ::boost::detail::win32::SetEvent(event_handle);
+                    }
+                    throw;
+                }
+            }
+
+            if(!counted)
+            {
+                BOOST_INTERLOCKED_INCREMENT(&flag.count);
+                counted=true;
+                status=::boost::detail::interlocked_read_acquire(&flag.status);
+                if(status==function_complete_flag_value)
+                {
+                    break;
+                }
+                if(!event_handle)
+                {
+                    event_handle=detail::create_once_event(mutex_name,&flag);
+                    continue;
+                }
+            }
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObject(
+                             event_handle,::boost::detail::win32::infinite));
+        }
+    }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/recursive_mutex.hpp

@@ -0,0 +1,68 @@
+#ifndef BOOST_RECURSIVE_MUTEX_WIN32_HPP
+#define BOOST_RECURSIVE_MUTEX_WIN32_HPP
+
+//  recursive_mutex.hpp
+//
+//  (C) Copyright 2006-7 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/utility.hpp>
+#include "basic_recursive_mutex.hpp"
+#include <boost/thread/exceptions.hpp>
+#include <boost/thread/locks.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class recursive_mutex:
+        public ::boost::detail::basic_recursive_mutex
+    {
+    private:
+        recursive_mutex(recursive_mutex const&);
+        recursive_mutex& operator=(recursive_mutex const&);        
+    public:
+        recursive_mutex()
+        {
+            ::boost::detail::basic_recursive_mutex::initialize();
+        }
+        ~recursive_mutex()
+        {
+            ::boost::detail::basic_recursive_mutex::destroy();
+        }
+
+        typedef unique_lock<recursive_mutex> scoped_lock;
+        typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
+    };
+
+    typedef recursive_mutex recursive_try_mutex;
+
+    class recursive_timed_mutex:
+        public ::boost::detail::basic_recursive_timed_mutex
+    {
+    private:
+        recursive_timed_mutex(recursive_timed_mutex const&);
+        recursive_timed_mutex& operator=(recursive_timed_mutex const&);        
+    public:
+        recursive_timed_mutex()
+        {
+            ::boost::detail::basic_recursive_timed_mutex::initialize();
+        }
+        ~recursive_timed_mutex()
+        {
+            ::boost::detail::basic_recursive_timed_mutex::destroy();
+        }
+
+        typedef unique_lock<recursive_timed_mutex> scoped_timed_lock;
+        typedef detail::try_lock_wrapper<recursive_timed_mutex> scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/shared_mutex.hpp

@@ -0,0 +1,603 @@
+#ifndef BOOST_THREAD_WIN32_SHARED_MUTEX_HPP
+#define BOOST_THREAD_WIN32_SHARED_MUTEX_HPP
+
+//  (C) Copyright 2006-8 Anthony Williams
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/assert.hpp>
+#include <boost/detail/interlocked.hpp>
+#include <boost/thread/win32/thread_primitives.hpp>
+#include <boost/static_assert.hpp>
+#include <limits.h>
+#include <boost/utility.hpp>
+#include <boost/thread/thread_time.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    class shared_mutex
+    {
+    private:
+        shared_mutex(shared_mutex const&);
+        shared_mutex& operator=(shared_mutex const&);        
+    private:
+        struct state_data
+        {
+            unsigned shared_count:11,
+                shared_waiting:11,
+                exclusive:1,
+                upgrade:1,
+                exclusive_waiting:7,
+                exclusive_waiting_blocked:1;
+
+            friend bool operator==(state_data const& lhs,state_data const& rhs)
+            {
+                return *reinterpret_cast<unsigned const*>(&lhs)==*reinterpret_cast<unsigned const*>(&rhs);
+            }
+        };
+        
+
+        template<typename T>
+        T interlocked_compare_exchange(T* target,T new_value,T comparand)
+        {
+            BOOST_STATIC_ASSERT(sizeof(T)==sizeof(long));
+            long const res=BOOST_INTERLOCKED_COMPARE_EXCHANGE(reinterpret_cast<long*>(target),
+                                                              *reinterpret_cast<long*>(&new_value),
+                                                              *reinterpret_cast<long*>(&comparand));
+            return *reinterpret_cast<T const*>(&res);
+        }
+
+        enum
+        {
+            unlock_sem = 0,
+            exclusive_sem = 1
+        };
+
+        state_data state;
+        detail::win32::handle semaphores[2];
+        detail::win32::handle upgrade_sem;
+
+        void release_waiters(state_data old_state)
+        {
+            if(old_state.exclusive_waiting)
+            {
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
+            }
+                        
+            if(old_state.shared_waiting || old_state.exclusive_waiting)
+            {
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+            }
+        }
+        
+
+    public:
+        shared_mutex()
+        {
+            semaphores[unlock_sem]=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            semaphores[exclusive_sem]=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            upgrade_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            state_data state_={0};
+            state=state_;
+        }
+
+        ~shared_mutex()
+        {
+            detail::win32::CloseHandle(upgrade_sem);
+            detail::win32::CloseHandle(semaphores[unlock_sem]);
+            detail::win32::CloseHandle(semaphores[exclusive_sem]);
+        }
+
+        bool try_lock_shared()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                if(!new_state.exclusive && !new_state.exclusive_waiting_blocked)
+                {
+                    ++new_state.shared_count;
+                    if(!new_state.shared_count)
+                    {
+                        return false;
+                    }
+                }
+                
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            return !(old_state.exclusive| old_state.exclusive_waiting_blocked);
+        }
+
+        void lock_shared()
+        {
+            BOOST_VERIFY(timed_lock_shared(::boost::detail::get_system_time_sentinel()));
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock_shared(TimeDuration const & relative_time)
+        {
+            return timed_lock_shared(get_system_time()+relative_time);
+        }
+
+        bool timed_lock_shared(boost::system_time const& wait_until)
+        {
+            for(;;)
+            {
+                state_data old_state=state;
+                for(;;)
+                {
+                    state_data new_state=old_state;
+                    if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+                    {
+                        ++new_state.shared_waiting;
+                        if(!new_state.shared_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                    }
+                    else
+                    {
+                        ++new_state.shared_count;
+                        if(!new_state.shared_count)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                    }
+
+                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                    if(current_state==old_state)
+                    {
+                        break;
+                    }
+                    old_state=current_state;
+                }
+
+                if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+                {
+                    return true;
+                }
+                    
+                unsigned long const res=detail::win32::WaitForSingleObject(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until));
+                if(res==detail::win32::timeout)
+                {
+                    for(;;)
+                    {
+                        state_data new_state=old_state;
+                        if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+                        {
+                            if(new_state.shared_waiting)
+                            {
+                                --new_state.shared_waiting;
+                            }
+                        }
+                        else
+                        {
+                            ++new_state.shared_count;
+                            if(!new_state.shared_count)
+                            {
+                                return false;
+                            }
+                        }
+
+                        state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                        if(current_state==old_state)
+                        {
+                            break;
+                        }
+                        old_state=current_state;
+                    }
+
+                    if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+                
+                BOOST_ASSERT(res==0);
+            }
+        }
+
+        void unlock_shared()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                bool const last_reader=!--new_state.shared_count;
+                
+                if(last_reader)
+                {
+                    if(new_state.upgrade)
+                    {
+                        new_state.upgrade=false;
+                        new_state.exclusive=true;
+                    }
+                    else
+                    {
+                        if(new_state.exclusive_waiting)
+                        {
+                            --new_state.exclusive_waiting;
+                            new_state.exclusive_waiting_blocked=false;
+                        }
+                        new_state.shared_waiting=0;
+                    }
+                }
+                
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    if(last_reader)
+                    {
+                        if(old_state.upgrade)
+                        {
+                            BOOST_VERIFY(detail::win32::ReleaseSemaphore(upgrade_sem,1,0)!=0);
+                        }
+                        else
+                        {
+                            release_waiters(old_state);
+                        }
+                    }
+                    break;
+                }
+                old_state=current_state;
+            }
+        }
+
+        void lock()
+        {
+            BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
+        }
+
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const & relative_time)
+        {
+            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(;;)
+            {
+                state_data old_state=state;
+
+                for(;;)
+                {
+                    state_data new_state=old_state;
+                    if(new_state.shared_count || new_state.exclusive)
+                    {
+                        ++new_state.exclusive_waiting;
+                        if(!new_state.exclusive_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                        
+                        new_state.exclusive_waiting_blocked=true;
+                    }
+                    else
+                    {
+                        new_state.exclusive=true;
+                    }
+
+                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                    if(current_state==old_state)
+                    {
+                        break;
+                    }
+                    old_state=current_state;
+                }
+
+                if(!old_state.shared_count && !old_state.exclusive)
+                {
+                    return true;
+                }
+                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(;;)
+                    {
+                        state_data new_state=old_state;
+                        if(new_state.shared_count || new_state.exclusive)
+                        {
+                            if(new_state.exclusive_waiting)
+                            {
+                                if(!--new_state.exclusive_waiting)
+                                {
+                                    new_state.exclusive_waiting_blocked=false;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            new_state.exclusive=true;
+                        }
+
+                        state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                        if(current_state==old_state)
+                        {
+                            break;
+                        }
+                        old_state=current_state;
+                    }
+                    if(!old_state.shared_count && !old_state.exclusive)
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+                BOOST_ASSERT(wait_res<2);
+            }
+        }
+
+        void unlock()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.exclusive=false;
+                if(new_state.exclusive_waiting)
+                {
+                    --new_state.exclusive_waiting;
+                    new_state.exclusive_waiting_blocked=false;
+                }
+                new_state.shared_waiting=0;
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            release_waiters(old_state);
+        }
+
+        void lock_upgrade()
+        {
+            for(;;)
+            {
+                state_data old_state=state;
+                for(;;)
+                {
+                    state_data new_state=old_state;
+                    if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
+                    {
+                        ++new_state.shared_waiting;
+                        if(!new_state.shared_waiting)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                    }
+                    else
+                    {
+                        ++new_state.shared_count;
+                        if(!new_state.shared_count)
+                        {
+                            boost::throw_exception(boost::lock_error());
+                        }
+                        new_state.upgrade=true;
+                    }
+
+                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                    if(current_state==old_state)
+                    {
+                        break;
+                    }
+                    old_state=current_state;
+                }
+
+                if(!(old_state.exclusive|| old_state.exclusive_waiting_blocked|| old_state.upgrade))
+                {
+                    return;
+                }
+                    
+                BOOST_VERIFY(!detail::win32::WaitForSingleObject(semaphores[unlock_sem],detail::win32::infinite));
+            }
+        }
+
+        bool try_lock_upgrade()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
+                {
+                    return false;
+                }
+                else
+                {
+                    ++new_state.shared_count;
+                    if(!new_state.shared_count)
+                    {
+                        return false;
+                    }
+                    new_state.upgrade=true;
+                }
+                
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            return true;
+        }
+
+        void unlock_upgrade()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.upgrade=false;
+                bool const last_reader=!--new_state.shared_count;
+                
+                if(last_reader)
+                {
+                    if(new_state.exclusive_waiting)
+                    {
+                        --new_state.exclusive_waiting;
+                        new_state.exclusive_waiting_blocked=false;
+                    }
+                    new_state.shared_waiting=0;
+                }
+                
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    if(last_reader)
+                    {
+                        release_waiters(old_state);
+                    }
+                    break;
+                }
+                old_state=current_state;
+            }
+        }
+
+        void unlock_upgrade_and_lock()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                bool const last_reader=!--new_state.shared_count;
+                
+                if(last_reader)
+                {
+                    new_state.upgrade=false;
+                    new_state.exclusive=true;
+                }
+                
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    if(!last_reader)
+                    {
+                        BOOST_VERIFY(!detail::win32::WaitForSingleObject(upgrade_sem,detail::win32::infinite));
+                    }
+                    break;
+                }
+                old_state=current_state;
+            }
+        }
+
+        void unlock_and_lock_upgrade()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.exclusive=false;
+                new_state.upgrade=true;
+                ++new_state.shared_count;
+                if(new_state.exclusive_waiting)
+                {
+                    --new_state.exclusive_waiting;
+                    new_state.exclusive_waiting_blocked=false;
+                }
+                new_state.shared_waiting=0;
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            release_waiters(old_state);
+        }
+        
+        void unlock_and_lock_shared()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.exclusive=false;
+                ++new_state.shared_count;
+                if(new_state.exclusive_waiting)
+                {
+                    --new_state.exclusive_waiting;
+                    new_state.exclusive_waiting_blocked=false;
+                }
+                new_state.shared_waiting=0;
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            release_waiters(old_state);
+        }
+        
+        void unlock_upgrade_and_lock_shared()
+        {
+            state_data old_state=state;
+            for(;;)
+            {
+                state_data new_state=old_state;
+                new_state.upgrade=false;
+                if(new_state.exclusive_waiting)
+                {
+                    --new_state.exclusive_waiting;
+                    new_state.exclusive_waiting_blocked=false;
+                }
+                new_state.shared_waiting=0;
+
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            release_waiters(old_state);
+        }
+        
+    };
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/thread_data.hpp

@@ -0,0 +1,183 @@
+#ifndef BOOST_THREAD_PTHREAD_THREAD_DATA_HPP
+#define BOOST_THREAD_PTHREAD_THREAD_DATA_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 2008 Anthony Williams
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/thread/thread_time.hpp>
+#include "thread_primitives.hpp"
+#include "thread_heap_alloc.hpp"
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        struct thread_exit_callback_node;
+        struct tss_data_node;
+
+        struct thread_data_base;
+        void intrusive_ptr_add_ref(thread_data_base * p);
+        void intrusive_ptr_release(thread_data_base * p);
+        
+        struct thread_data_base
+        {
+            long count;
+            detail::win32::handle_manager thread_handle;
+            detail::win32::handle_manager interruption_handle;
+            boost::detail::thread_exit_callback_node* thread_exit_callbacks;
+            boost::detail::tss_data_node* tss_data;
+            bool interruption_enabled;
+            unsigned id;
+
+            thread_data_base():
+                count(0),thread_handle(detail::win32::invalid_handle_value),
+                interruption_handle(create_anonymous_event(detail::win32::manual_reset_event,detail::win32::event_initially_reset)),
+                thread_exit_callbacks(0),tss_data(0),
+                interruption_enabled(true),
+                id(0)
+            {}
+            virtual ~thread_data_base()
+            {}
+
+            friend void intrusive_ptr_add_ref(thread_data_base * p)
+            {
+                BOOST_INTERLOCKED_INCREMENT(&p->count);
+            }
+            
+            friend void intrusive_ptr_release(thread_data_base * p)
+            {
+                if(!BOOST_INTERLOCKED_DECREMENT(&p->count))
+                {
+                    detail::heap_delete(p);
+                }
+            }
+
+            void interrupt()
+            {
+                BOOST_VERIFY(detail::win32::SetEvent(interruption_handle)!=0);
+            }
+            
+            typedef detail::win32::handle native_handle_type;
+
+            virtual void run()=0;
+        };
+
+        typedef boost::intrusive_ptr<detail::thread_data_base> thread_data_ptr;
+
+        struct timeout
+        {
+            unsigned long start;
+            uintmax_t milliseconds;
+            bool relative;
+            boost::system_time abs_time;
+
+            static unsigned long const max_non_infinite_wait=0xfffffffe;
+
+            timeout(uintmax_t milliseconds_):
+                start(win32::GetTickCount()),
+                milliseconds(milliseconds_),
+                relative(true),
+                abs_time(boost::get_system_time())
+            {}
+
+            timeout(boost::system_time const& abs_time_):
+                start(win32::GetTickCount()),
+                milliseconds(0),
+                relative(false),
+                abs_time(abs_time_)
+            {}
+
+            struct remaining_time
+            {
+                bool more;
+                unsigned long milliseconds;
+
+                remaining_time(uintmax_t remaining):
+                    more(remaining>max_non_infinite_wait),
+                    milliseconds(more?max_non_infinite_wait:(unsigned long)remaining)
+                {}
+            };
+
+            remaining_time remaining_milliseconds() const
+            {
+                if(is_sentinel())
+                {
+                    return remaining_time(win32::infinite);
+                }
+                else if(relative)
+                {
+                    unsigned long const now=win32::GetTickCount();
+                    unsigned long const elapsed=now-start;
+                    return remaining_time((elapsed<milliseconds)?(milliseconds-elapsed):0);
+                }
+                else
+                {
+                    system_time const now=get_system_time();
+                    if(abs_time<=now)
+                    {
+                        return remaining_time(0);
+                    }
+                    return remaining_time((abs_time-now).total_milliseconds()+1);
+                }
+            }
+
+            bool is_sentinel() const
+            {
+                return milliseconds==~uintmax_t(0);
+            }
+            
+
+            static timeout sentinel()
+            {
+                return timeout(sentinel_type());
+            }
+        private:
+            struct sentinel_type
+            {};
+                
+            explicit timeout(sentinel_type):
+                start(0),milliseconds(~uintmax_t(0)),relative(true)
+            {}
+        };
+
+        inline uintmax_t pin_to_zero(intmax_t value)
+        {
+            return (value<0)?0u:(uintmax_t)value;
+        }
+    }
+
+    namespace this_thread
+    {
+        void BOOST_THREAD_DECL yield();
+
+        bool BOOST_THREAD_DECL interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time);
+        inline void interruptible_wait(uintmax_t milliseconds)
+        {
+            interruptible_wait(detail::win32::invalid_handle_value,milliseconds);
+        }
+        inline void interruptible_wait(system_time const& abs_time)
+        {
+            interruptible_wait(detail::win32::invalid_handle_value,abs_time);
+        }
+
+        template<typename TimeDuration>
+        inline void sleep(TimeDuration const& rel_time)
+        {
+            interruptible_wait(detail::pin_to_zero(rel_time.total_milliseconds()));
+        }
+        inline void sleep(system_time const& abs_time)
+        {
+            interruptible_wait(abs_time);
+        }
+    }
+    
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/thread_heap_alloc.hpp

@@ -0,0 +1,398 @@
+// 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 Anthony Williams
+#ifndef THREAD_HEAP_ALLOC_HPP
+#define THREAD_HEAP_ALLOC_HPP
+#include <new>
+#include "thread_primitives.hpp"
+#include <stdexcept>
+#include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>
+
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            using ::GetProcessHeap;
+            using ::HeapAlloc;
+            using ::HeapFree;
+        }
+    }
+}
+
+#else
+
+# ifdef HeapAlloc
+# undef HeapAlloc
+# endif
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            extern "C"
+            {
+                __declspec(dllimport) handle __stdcall GetProcessHeap();
+                __declspec(dllimport) void* __stdcall HeapAlloc(handle,unsigned long,ulong_ptr);
+                __declspec(dllimport) int __stdcall HeapFree(handle,unsigned long,void*);
+            }
+        }
+    }
+}
+
+#endif
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        inline BOOST_THREAD_DECL void* allocate_raw_heap_memory(unsigned size)
+        {
+            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,size);
+            if(!heap_memory)
+            {
+                boost::throw_exception(std::bad_alloc());
+            }
+            return heap_memory;
+        }
+
+        inline BOOST_THREAD_DECL void free_raw_heap_memory(void* heap_memory)
+        {
+            BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0);
+        }
+            
+        template<typename T>
+        inline T* heap_new()
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T();
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+        template<typename T,typename A1>
+        inline T* heap_new(A1&& a1)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(static_cast<A1&&>(a1));
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1&& a1,A2&& a2)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
+                                                  static_cast<A3&&>(a3));
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
+                                                  static_cast<A3&&>(a3),static_cast<A4&&>(a4));
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+#else
+        template<typename T,typename A1>
+        inline T* heap_new_impl(A1 a1)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(a1);
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new_impl(A1 a1,A2 a2)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(a1,a2);
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(a1,a2,a3);
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(a1,a2,a3,a4);
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+
+
+        template<typename T,typename A1>
+        inline T* heap_new(A1 const& a1)
+        {
+            return heap_new_impl<T,A1 const&>(a1);
+        }
+        template<typename T,typename A1>
+        inline T* heap_new(A1& a1)
+        {
+            return heap_new_impl<T,A1&>(a1);
+        }
+        
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1 const& a1,A2 const& a2)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1& a1,A2 const& a2)
+        {
+            return heap_new_impl<T,A1&,A2 const&>(a1,a2);
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1 const& a1,A2& a2)
+        {
+            return heap_new_impl<T,A1 const&,A2&>(a1,a2);
+        }
+        template<typename T,typename A1,typename A2>
+        inline T* heap_new(A1& a1,A2& a2)
+        {
+            return heap_new_impl<T,A1&,A2&>(a1,a2);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
+        {
+            return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
+        }
+        template<typename T,typename A1,typename A2,typename A3>
+        inline T* heap_new(A1& a1,A2& a2,A3& a3)
+        {
+            return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
+        {
+            return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
+        }
+
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
+        }
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
+        {
+            return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
+        }
+        
+#endif        
+        template<typename T>
+        inline void heap_delete(T* data)
+        {
+            data->~T();
+            free_raw_heap_memory(data);
+        }
+
+        template<typename T>
+        struct do_heap_delete
+        {
+            void operator()(T* data) const
+            {
+                detail::heap_delete(data);
+            }
+        };
+    }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+
+#endif

include/boost/thread/win32/thread_primitives.hpp

@@ -0,0 +1,407 @@
+#ifndef BOOST_WIN32_THREAD_PRIMITIVES_HPP
+#define BOOST_WIN32_THREAD_PRIMITIVES_HPP
+
+//  win32_thread_primitives.hpp
+//
+//  (C) Copyright 2005-7 Anthony Williams 
+//  (C) Copyright 2007 David Deakins 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/assert.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <boost/detail/interlocked.hpp>
+#include <algorithm>
+
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            typedef ULONG_PTR ulong_ptr;
+            typedef HANDLE handle;
+            unsigned const infinite=INFINITE;
+            unsigned const timeout=WAIT_TIMEOUT;
+            handle const invalid_handle_value=INVALID_HANDLE_VALUE;
+            unsigned const event_modify_state=EVENT_MODIFY_STATE;
+            unsigned const synchronize=SYNCHRONIZE;
+
+# ifdef BOOST_NO_ANSI_APIS
+            using ::CreateMutexW;
+            using ::CreateEventW;
+            using ::OpenEventW;
+            using ::CreateSemaphoreW;
+# else
+            using ::CreateMutexA;
+            using ::CreateEventA;
+            using ::OpenEventA;
+            using ::CreateSemaphoreA;
+# endif
+            using ::CloseHandle;
+            using ::ReleaseMutex;
+            using ::ReleaseSemaphore;
+            using ::SetEvent;
+            using ::ResetEvent;
+            using ::WaitForMultipleObjects;
+            using ::WaitForSingleObject;
+            using ::GetCurrentProcessId;
+            using ::GetCurrentThreadId;
+            using ::GetCurrentThread;
+            using ::GetCurrentProcess;
+            using ::DuplicateHandle;
+            using ::SleepEx;
+            using ::Sleep;
+            using ::QueueUserAPC;
+            using ::GetTickCount;
+        }
+    }
+}
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+
+# ifdef UNDER_CE
+#  ifndef WINAPI
+#   ifndef _WIN32_WCE_EMULATION
+#    define WINAPI  __cdecl     // Note this doesn't match the desktop definition
+#   else
+#    define WINAPI  __stdcall
+#   endif
+#  endif
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+typedef int BOOL;
+typedef unsigned long DWORD;
+typedef void* HANDLE;
+
+#  include <kfuncs.h>
+#  ifdef __cplusplus
+}
+#  endif
+# endif
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            
+# ifdef _WIN64
+            typedef unsigned __int64 ulong_ptr;
+# else
+            typedef unsigned long ulong_ptr;
+# endif
+            typedef void* handle;
+            unsigned const infinite=~0U;
+            unsigned const timeout=258U;
+            handle const invalid_handle_value=(handle)(-1);
+            unsigned const event_modify_state=2;
+            unsigned const synchronize=0x100000u;
+
+            extern "C"
+            {
+                struct _SECURITY_ATTRIBUTES;
+# ifdef BOOST_NO_ANSI_APIS
+                __declspec(dllimport) void* __stdcall CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall OpenEventW(unsigned long,int,wchar_t const*);
+# else
+                __declspec(dllimport) void* __stdcall CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
+                __declspec(dllimport) void* __stdcall CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+                __declspec(dllimport) void* __stdcall OpenEventA(unsigned long,int,char const*);
+# endif
+                __declspec(dllimport) int __stdcall CloseHandle(void*);
+                __declspec(dllimport) int __stdcall ReleaseMutex(void*);
+                __declspec(dllimport) unsigned long __stdcall WaitForSingleObject(void*,unsigned long);
+                __declspec(dllimport) unsigned long __stdcall WaitForMultipleObjects(unsigned long nCount,void* const * lpHandles,int bWaitAll,unsigned long dwMilliseconds);
+                __declspec(dllimport) int __stdcall ReleaseSemaphore(void*,long,long*);
+                __declspec(dllimport) int __stdcall DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long);
+                __declspec(dllimport) unsigned long __stdcall SleepEx(unsigned long,int);
+                __declspec(dllimport) void __stdcall Sleep(unsigned long);
+                typedef void (__stdcall *queue_user_apc_callback_function)(ulong_ptr);
+                __declspec(dllimport) unsigned long __stdcall QueueUserAPC(queue_user_apc_callback_function,void*,ulong_ptr);
+
+                __declspec(dllimport) unsigned long __stdcall GetTickCount();
+
+# ifndef UNDER_CE
+                __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
+                __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
+                __declspec(dllimport) void* __stdcall GetCurrentThread();
+                __declspec(dllimport) void* __stdcall GetCurrentProcess();
+                __declspec(dllimport) int __stdcall SetEvent(void*);
+                __declspec(dllimport) int __stdcall ResetEvent(void*);
+# else
+                using ::GetCurrentProcessId;
+                using ::GetCurrentThreadId;
+                using ::GetCurrentThread;
+                using ::GetCurrentProcess;
+                using ::SetEvent;
+                using ::ResetEvent;
+# endif
+            }
+        }
+    }
+}
+#else
+# error "Win32 functions not available"
+#endif
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            enum event_type
+            {
+                auto_reset_event=false,
+                manual_reset_event=true
+            };
+            
+            enum initial_event_state
+            {
+                event_initially_reset=false,
+                event_initially_set=true
+            };
+            
+            inline handle create_anonymous_event(event_type type,initial_event_state state)
+            {
+#if !defined(BOOST_NO_ANSI_APIS)  
+                handle const res=win32::CreateEventA(0,type,state,0);
+#else
+                handle const res=win32::CreateEventW(0,type,state,0);
+#endif                
+                if(!res)
+                {
+                    boost::throw_exception(thread_resource_error());
+                }
+                return res;
+            }
+
+            inline handle create_anonymous_semaphore(long initial_count,long max_count)
+            {
+#if !defined(BOOST_NO_ANSI_APIS)  
+                handle const res=CreateSemaphoreA(0,initial_count,max_count,0);
+#else
+                handle const res=CreateSemaphoreW(0,initial_count,max_count,0);
+#endif               
+                if(!res)
+                {
+                    boost::throw_exception(thread_resource_error());
+                }
+                return res;
+            }
+
+            inline handle duplicate_handle(handle source)
+            {
+                handle const current_process=GetCurrentProcess();
+                long const same_access_flag=2;
+                handle new_handle=0;
+                bool const success=DuplicateHandle(current_process,source,current_process,&new_handle,0,false,same_access_flag)!=0;
+                if(!success)
+                {
+                    boost::throw_exception(thread_resource_error());
+                }
+                return new_handle;
+            }
+
+            inline void release_semaphore(handle semaphore,long count)
+            {
+                BOOST_VERIFY(ReleaseSemaphore(semaphore,count,0)!=0);
+            }
+
+            class handle_manager
+            {
+            private:
+                handle handle_to_manage;
+                handle_manager(handle_manager&);
+                handle_manager& operator=(handle_manager&);
+
+                void cleanup()
+                {
+                    if(handle_to_manage && handle_to_manage!=invalid_handle_value)
+                    {
+                        BOOST_VERIFY(CloseHandle(handle_to_manage));
+                    }
+                }
+                
+            public:
+                explicit handle_manager(handle handle_to_manage_):
+                    handle_to_manage(handle_to_manage_)
+                {}
+                handle_manager():
+                    handle_to_manage(0)
+                {}
+                
+                handle_manager& operator=(handle new_handle)
+                {
+                    cleanup();
+                    handle_to_manage=new_handle;
+                    return *this;
+                }
+
+                operator handle() const
+                {
+                    return handle_to_manage;
+                }
+
+                handle duplicate() const
+                {
+                    return duplicate_handle(handle_to_manage);
+                }
+
+                void swap(handle_manager& other)
+                {
+                    std::swap(handle_to_manage,other.handle_to_manage);
+                }
+
+                handle release()
+                {
+                    handle const res=handle_to_manage;
+                    handle_to_manage=0;
+                    return res;
+                }
+
+                bool operator!() const
+                {
+                    return !handle_to_manage;
+                }
+                
+                ~handle_manager()
+                {
+                    cleanup();
+                }
+            };
+            
+        }
+    }
+}
+
+#if defined(BOOST_MSVC) && (_MSC_VER>=1400)  && !defined(UNDER_CE)
+
+namespace boost
+{
+    namespace detail
+    {
+        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;
+            }
+
+            inline bool interlocked_bit_test_and_reset(long* x,long bit)
+            {
+                return _interlockedbittestandreset(x,bit)!=0;
+            }
+            
+        }
+    }
+}
+#define BOOST_THREAD_BTS_DEFINED
+#elif (defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN)) && defined(_M_IX86)
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            inline bool interlocked_bit_test_and_set(long* x,long bit)
+            {
+                __asm {
+                    mov eax,bit;
+                    mov edx,x;
+                    lock bts [edx],eax;
+                    setc al;
+                };          
+            }
+
+            inline bool interlocked_bit_test_and_reset(long* x,long bit)
+            {
+                __asm {
+                    mov eax,bit;
+                    mov edx,x;
+                    lock btr [edx],eax;
+                    setc al;
+                };          
+            }
+            
+        }
+    }
+}
+#define BOOST_THREAD_BTS_DEFINED
+#endif
+
+#ifndef BOOST_THREAD_BTS_DEFINED
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            inline bool interlocked_bit_test_and_set(long* x,long bit)
+            {
+                long const value=1<<bit;
+                long old=*x;
+                do
+                {
+                    long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(x,old|value,old);
+                    if(current==old)
+                    {
+                        break;
+                    }
+                    old=current;
+                }
+                while(true);
+                return (old&value)!=0;
+            }
+
+            inline bool interlocked_bit_test_and_reset(long* x,long bit)
+            {
+                long const value=1<<bit;
+                long old=*x;
+                do
+                {
+                    long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(x,old&~value,old);
+                    if(current==old)
+                    {
+                        break;
+                    }
+                    old=current;
+                }
+                while(true);
+                return (old&value)!=0;
+            }
+        }
+    }
+}
+#endif
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/xtime.hpp

@@ -0,0 +1,92 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+// Copyright (C) 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)
+
+#ifndef BOOST_XTIME_WEK070601_HPP
+#define BOOST_XTIME_WEK070601_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/cstdint.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost {
+
+enum xtime_clock_types
+{
+    TIME_UTC=1
+//    TIME_TAI,
+//    TIME_MONOTONIC,
+//    TIME_PROCESS,
+//    TIME_THREAD,
+//    TIME_LOCAL,
+//    TIME_SYNC,
+//    TIME_RESOLUTION
+};
+
+struct xtime
+{
+#if defined(BOOST_NO_INT64_T)
+    typedef int_fast32_t xtime_sec_t; //INT_FAST32_MIN <= sec <= INT_FAST32_MAX
+#else
+    typedef int_fast64_t xtime_sec_t; //INT_FAST64_MIN <= sec <= INT_FAST64_MAX
+#endif
+
+    typedef int_fast32_t xtime_nsec_t; //0 <= xtime.nsec < NANOSECONDS_PER_SECOND
+
+    xtime_sec_t sec;
+    xtime_nsec_t nsec;
+
+    operator system_time() const
+    {
+        return boost::posix_time::from_time_t(0)+
+            boost::posix_time::seconds(static_cast<long>(sec))+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+            boost::posix_time::nanoseconds(nsec);
+#else
+        boost::posix_time::microseconds((nsec+500)/1000);
+#endif
+    }
+    
+};
+
+inline xtime get_xtime(boost::system_time const& abs_time)
+{
+    xtime res;
+    boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
+            
+    res.sec=static_cast<xtime::xtime_sec_t>(time_since_epoch.total_seconds());
+    res.nsec=static_cast<xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
+    return res;
+}
+
+inline int xtime_get(struct xtime* xtp, int clock_type)
+{
+    if (clock_type == TIME_UTC)
+    {
+        *xtp=get_xtime(get_system_time());
+        return clock_type;
+    }
+    return 0;
+}
+
+
+inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
+{
+    if (xt1.sec == xt2.sec)
+        return (int)(xt1.nsec - xt2.nsec);
+    else 
+        return (xt1.sec > xt2.sec) ? 1 : -1;
+}
+
+} // namespace boost
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif //BOOST_XTIME_WEK070601_HPP

index.html

@@ -0,0 +1,13 @@
+<!-- Copyright (c) 2002-2003 William E. Kempf.
+     Subject to the Boost Software License, Version 1.0. 
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
+-->
+
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=doc/index.html">
+</head>
+<body>
+Automatic redirection failed, please go to <a href="doc/index.html">doc/index.html</a>
+</body>
+</html>

src/pthread/once.cpp

@@ -0,0 +1,53 @@
+// 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)
+
+#define __STDC_CONSTANT_MACROS
+#include <boost/thread/once.hpp>
+#include <boost/assert.hpp>
+#include <pthread.h>
+#include <stdlib.h>
+
+namespace boost
+{
+    namespace detail
+    {
+        BOOST_THREAD_DECL boost::uintmax_t once_global_epoch=UINTMAX_C(~0);
+        BOOST_THREAD_DECL pthread_mutex_t once_epoch_mutex=PTHREAD_MUTEX_INITIALIZER;
+        BOOST_THREAD_DECL pthread_cond_t once_epoch_cv = PTHREAD_COND_INITIALIZER;
+
+        namespace
+        {
+            pthread_key_t epoch_tss_key;
+            pthread_once_t epoch_tss_key_flag=PTHREAD_ONCE_INIT;
+            
+            extern "C"
+            {
+                static void delete_epoch_tss_data(void* data)
+                {
+                    free(data);
+                }
+
+                static void create_epoch_tss_key()
+                {
+                    BOOST_VERIFY(!pthread_key_create(&epoch_tss_key,delete_epoch_tss_data));
+                }
+            }
+        }
+        
+        boost::uintmax_t& get_once_per_thread_epoch()
+        {
+            BOOST_VERIFY(!pthread_once(&epoch_tss_key_flag,create_epoch_tss_key));
+            void* data=pthread_getspecific(epoch_tss_key);
+            if(!data)
+            {
+                data=malloc(sizeof(boost::uintmax_t));
+                BOOST_VERIFY(!pthread_setspecific(epoch_tss_key,data));
+                *static_cast<boost::uintmax_t*>(data)=UINTMAX_C(~0);
+            }
+            return *static_cast<boost::uintmax_t*>(data);
+        }
+    }
+    
+}

src/pthread/thread.cpp

@@ -0,0 +1,602 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+// Copyright (C) 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/thread.hpp>
+#include <boost/thread/xtime.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/once.hpp>
+#include <boost/thread/tss.hpp>
+#include <boost/throw_exception.hpp>
+#ifdef __linux__
+#include <sys/sysinfo.h>
+#elif defined(__APPLE__) || defined(__FreeBSD__)
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#elif defined BOOST_HAS_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "timeconv.inl"
+
+namespace boost
+{
+    namespace detail
+    {
+        thread_data_base::~thread_data_base()
+        {}
+
+        struct thread_exit_callback_node
+        {
+            boost::detail::thread_exit_function_base* func;
+            thread_exit_callback_node* next;
+
+            thread_exit_callback_node(boost::detail::thread_exit_function_base* func_,
+                                      thread_exit_callback_node* next_):
+                func(func_),next(next_)
+            {}
+        };
+
+        namespace
+        {
+            boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
+            pthread_key_t current_thread_tls_key;
+
+            extern "C"
+            {
+                static void tls_destructor(void* data)
+                {
+                    boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
+                    if(thread_info)
+                    {
+                        while(!thread_info->tss_data.empty() || thread_info->thread_exit_callbacks)
+                        {
+                            while(thread_info->thread_exit_callbacks)
+                            {
+                                detail::thread_exit_callback_node* const current_node=thread_info->thread_exit_callbacks;
+                                thread_info->thread_exit_callbacks=current_node->next;
+                                if(current_node->func)
+                                {
+                                    (*current_node->func)();
+                                    delete current_node->func;
+                                }
+                                delete current_node;
+                            }
+                            for(std::map<void const*,tss_data_node>::iterator next=thread_info->tss_data.begin(),
+                                    current,
+                                    end=thread_info->tss_data.end();
+                                next!=end;)
+                            {
+                                current=next;
+                                ++next;
+                                if(current->second.func && (current->second.value!=0))
+                                {
+                                    (*current->second.func)(current->second.value);
+                                }
+                                thread_info->tss_data.erase(current);
+                            }
+                        }
+                        thread_info->self.reset();
+                    }
+                }
+            }
+    
+
+            void create_current_thread_tls_key()
+            {
+                BOOST_VERIFY(!pthread_key_create(&current_thread_tls_key,&tls_destructor));
+            }
+        }
+        
+        boost::detail::thread_data_base* get_current_thread_data()
+        {
+            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
+            return (boost::detail::thread_data_base*)pthread_getspecific(current_thread_tls_key);
+        }
+
+        void set_current_thread_data(detail::thread_data_base* new_data)
+        {
+            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
+            BOOST_VERIFY(!pthread_setspecific(current_thread_tls_key,new_data));
+        }
+    }
+    
+    namespace
+    {
+        extern "C"
+        {
+            static void* thread_proxy(void* param)
+            {
+                boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->self;
+                thread_info->self.reset();
+                detail::set_current_thread_data(thread_info.get());
+                try
+                {
+                    thread_info->run();
+                }
+                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();
+//                 }
+
+                detail::tls_destructor(thread_info.get());
+                detail::set_current_thread_data(0);
+                boost::lock_guard<boost::mutex> lock(thread_info->data_mutex);
+                thread_info->done=true;
+                thread_info->done_condition.notify_all();
+                return 0;
+            }
+        }
+
+        struct externally_launched_thread:
+            detail::thread_data_base
+        {
+            externally_launched_thread()
+            {
+                interrupt_enabled=false;
+            }
+            
+            void run()
+            {}
+
+        private:
+            externally_launched_thread(externally_launched_thread&);
+            void operator=(externally_launched_thread&);
+        };
+
+        detail::thread_data_base* make_external_thread_data()
+        {
+            detail::thread_data_base* const me(new externally_launched_thread());
+            me->self.reset(me);
+            set_current_thread_data(me);
+            return me;
+        }
+
+
+        detail::thread_data_base* get_or_make_current_thread_data()
+        {
+            detail::thread_data_base* current_thread_data(detail::get_current_thread_data());
+            if(!current_thread_data)
+            {
+                current_thread_data=make_external_thread_data();
+            }
+            return current_thread_data;
+        }
+
+    }
+
+
+    thread::thread()
+    {}
+
+    void thread::start_thread()
+    {
+        thread_info->self=thread_info;
+        int const res = pthread_create(&thread_info->thread_handle, 0, &thread_proxy, thread_info.get());
+        if (res != 0)
+        {
+            thread_info->self.reset();
+            boost::throw_exception(thread_resource_error());
+        }
+    }
+
+    thread::~thread()
+    {
+        detach();
+    }
+
+    detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    {
+        return thread_info;
+    }
+
+    void thread::join()
+    {
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            bool do_join=false;
+            
+            {
+                unique_lock<mutex> lock(local_thread_info->data_mutex);
+                while(!local_thread_info->done)
+                {
+                    local_thread_info->done_condition.wait(lock);
+                }
+                do_join=!local_thread_info->join_started;
+                
+                if(do_join)
+                {
+                    local_thread_info->join_started=true;
+                }
+                else
+                {
+                    while(!local_thread_info->joined)
+                    {
+                        local_thread_info->done_condition.wait(lock);
+                    }
+                }
+            }
+            if(do_join)
+            {
+                void* result=0;
+                BOOST_VERIFY(!pthread_join(local_thread_info->thread_handle,&result));
+                lock_guard<mutex> lock(local_thread_info->data_mutex);
+                local_thread_info->joined=true;
+                local_thread_info->done_condition.notify_all();
+            }
+            
+            if(thread_info==local_thread_info)
+            {
+                thread_info.reset();
+            }
+        }
+    }
+
+    bool thread::timed_join(system_time const& wait_until)
+    {
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            bool do_join=false;
+            
+            {
+                unique_lock<mutex> lock(local_thread_info->data_mutex);
+                while(!local_thread_info->done)
+                {
+                    if(!local_thread_info->done_condition.timed_wait(lock,wait_until))
+                    {
+                        return false;
+                    }
+                }
+                do_join=!local_thread_info->join_started;
+                
+                if(do_join)
+                {
+                    local_thread_info->join_started=true;
+                }
+                else
+                {
+                    while(!local_thread_info->joined)
+                    {
+                        local_thread_info->done_condition.wait(lock);
+                    }
+                }
+            }
+            if(do_join)
+            {
+                void* result=0;
+                BOOST_VERIFY(!pthread_join(local_thread_info->thread_handle,&result));
+                lock_guard<mutex> lock(local_thread_info->data_mutex);
+                local_thread_info->joined=true;
+                local_thread_info->done_condition.notify_all();
+            }
+            
+            if(thread_info==local_thread_info)
+            {
+                thread_info.reset();
+            }
+        }
+        return true;
+    }
+
+    bool thread::joinable() const
+    {
+        return (get_thread_info)();
+    }
+
+
+    void thread::detach()
+    {
+        detail::thread_data_ptr local_thread_info;
+        thread_info.swap(local_thread_info);
+        
+        if(local_thread_info)
+        {
+            lock_guard<mutex> lock(local_thread_info->data_mutex);
+            if(!local_thread_info->join_started)
+            {
+                BOOST_VERIFY(!pthread_detach(local_thread_info->thread_handle));
+                local_thread_info->join_started=true;
+                local_thread_info->joined=true;
+            }
+        }
+    }
+
+    namespace this_thread
+    {
+        
+        void sleep(const system_time& st)
+        {
+            detail::thread_data_base* const thread_info=detail::get_current_thread_data();
+        
+            if(thread_info)
+            {
+                unique_lock<mutex> lk(thread_info->sleep_mutex);
+                while(thread_info->sleep_condition.timed_wait(lk,st));
+            }
+            else
+            {
+                xtime const xt=get_xtime(st);
+            
+                for (int foo=0; foo < 5; ++foo)
+                {
+#   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
+                    timespec ts;
+                    to_timespec_duration(xt, ts);
+                    BOOST_VERIFY(!pthread_delay_np(&ts));
+#   elif defined(BOOST_HAS_NANOSLEEP)
+                    timespec ts;
+                    to_timespec_duration(xt, ts);
+                
+                    //  nanosleep takes a timespec that is an offset, not
+                    //  an absolute time.
+                    nanosleep(&ts, 0);
+#   else
+                    mutex mx;
+                    mutex::scoped_lock lock(mx);
+                    condition cond;
+                    cond.timed_wait(lock, xt);
+#   endif
+                    xtime cur;
+                    xtime_get(&cur, TIME_UTC);
+                    if (xtime_cmp(xt, cur) <= 0)
+                        return;
+                }
+            }
+        }
+
+        void yield()
+        {
+#   if defined(BOOST_HAS_SCHED_YIELD)
+            BOOST_VERIFY(!sched_yield());
+#   elif defined(BOOST_HAS_PTHREAD_YIELD)
+            BOOST_VERIFY(!pthread_yield());
+#   else
+            xtime xt;
+            xtime_get(&xt, TIME_UTC);
+            sleep(xt);
+#   endif
+        }
+    }
+
+    unsigned thread::hardware_concurrency()
+    {
+#if defined(PTW32_VERSION) || defined(__hpux)
+        return pthread_num_processors_np();
+#elif defined(__APPLE__) || defined(__FreeBSD__)
+        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)
+        int const count=sysconf(_SC_NPROCESSORS_ONLN);
+        return (count>0)?count:0;
+#elif defined(_GNU_SOURCE)
+        return get_nprocs();
+#else
+        return 0;
+#endif
+    }
+
+    thread::id thread::get_id() const
+    {
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            return id(local_thread_info);
+        }
+        else
+        {
+            return id();
+        }
+    }
+
+    void thread::interrupt()
+    {
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            lock_guard<mutex> lk(local_thread_info->data_mutex);
+            local_thread_info->interrupt_requested=true;
+            if(local_thread_info->current_cond)
+            {
+                boost::pthread::pthread_mutex_scoped_lock internal_lock(local_thread_info->cond_mutex);
+                BOOST_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond));
+            }
+        }
+    }
+
+    bool thread::interruption_requested() const
+    {
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            lock_guard<mutex> lk(local_thread_info->data_mutex);
+            return local_thread_info->interrupt_requested;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    thread::native_handle_type thread::native_handle()
+    {
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            lock_guard<mutex> lk(local_thread_info->data_mutex);
+            return local_thread_info->thread_handle;
+        }
+        else
+        {
+            return pthread_t();
+        }
+    }
+    
+    
+
+    namespace this_thread
+    {
+        thread::id get_id()
+        {
+            boost::detail::thread_data_base* const thread_info=get_or_make_current_thread_data();
+            return thread::id(thread_info?thread_info->shared_from_this():detail::thread_data_ptr());
+        }
+
+        void interruption_point()
+        {
+            boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data();
+            if(thread_info && thread_info->interrupt_enabled)
+            {
+                lock_guard<mutex> lg(thread_info->data_mutex);
+                if(thread_info->interrupt_requested)
+                {
+                    thread_info->interrupt_requested=false;
+                    throw thread_interrupted();
+                }
+            }
+        }
+        
+        bool interruption_enabled()
+        {
+            boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data();
+            return thread_info && thread_info->interrupt_enabled;
+        }
+        
+        bool interruption_requested()
+        {
+            boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data();
+            if(!thread_info)
+            {
+                return false;
+            }
+            else
+            {
+                lock_guard<mutex> lg(thread_info->data_mutex);
+                return thread_info->interrupt_requested;
+            }
+        }
+
+        disable_interruption::disable_interruption():
+            interruption_was_enabled(interruption_enabled())
+        {
+            if(interruption_was_enabled)
+            {
+                detail::get_current_thread_data()->interrupt_enabled=false;
+            }
+        }
+        
+        disable_interruption::~disable_interruption()
+        {
+            if(detail::get_current_thread_data())
+            {
+                detail::get_current_thread_data()->interrupt_enabled=interruption_was_enabled;
+            }
+        }
+
+        restore_interruption::restore_interruption(disable_interruption& d)
+        {
+            if(d.interruption_was_enabled)
+            {
+                detail::get_current_thread_data()->interrupt_enabled=true;
+            }
+        }
+        
+        restore_interruption::~restore_interruption()
+        {
+            if(detail::get_current_thread_data())
+            {
+                detail::get_current_thread_data()->interrupt_enabled=false;
+            }
+        }
+    }
+
+    namespace detail
+    {
+        void add_thread_exit_function(thread_exit_function_base* func)
+        {
+            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
+            thread_exit_callback_node* const new_node=
+                new thread_exit_callback_node(func,current_thread_data->thread_exit_callbacks);
+            current_thread_data->thread_exit_callbacks=new_node;
+        }
+
+        tss_data_node* find_tss_data(void const* key)
+        {
+            detail::thread_data_base* const current_thread_data(get_current_thread_data());
+            if(current_thread_data)
+            {
+                std::map<void const*,tss_data_node>::iterator current_node=
+                    current_thread_data->tss_data.find(key);
+                if(current_node!=current_thread_data->tss_data.end())
+                {
+                    return &current_node->second;
+                }
+            }
+            return NULL;
+        }
+
+        void* get_tss_data(void const* key)
+        {
+            if(tss_data_node* const current_node=find_tss_data(key))
+            {
+                return current_node->value;
+            }
+            return NULL;
+        }
+
+        void add_new_tss_node(void const* key,
+                              boost::shared_ptr<tss_cleanup_function> func,
+                              void* tss_data)
+        {
+            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
+            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(func,tss_data)));
+        }
+
+        void erase_tss_node(void const* key)
+        {
+            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
+            current_thread_data->tss_data.erase(key);
+        }
+        
+        void set_tss_data(void const* key,
+                          boost::shared_ptr<tss_cleanup_function> func,
+                          void* tss_data,bool cleanup_existing)
+        {
+            if(tss_data_node* const current_node=find_tss_data(key))
+            {
+                if(cleanup_existing && current_node->func && (current_node->value!=0))
+                {
+                    (*current_node->func)(current_node->value);
+                }
+                if(func || (tss_data!=0))
+                {
+                    current_node->func=func;
+                    current_node->value=tss_data;
+                }
+                else
+                {
+                    erase_tss_node(key);
+                }
+            }
+            else
+            {
+                add_new_tss_node(key,func,tss_data);
+            }
+        }
+    }
+
+
+}

src/pthread/timeconv.inl

@@ -0,0 +1,133 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+// Copyright (C) 2009 Anthony Williams
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// boostinspect:nounnamed
+
+#include <boost/assert.hpp>
+
+namespace {
+const int MILLISECONDS_PER_SECOND = 1000;
+const int NANOSECONDS_PER_SECOND = 1000000000;
+const int NANOSECONDS_PER_MILLISECOND = 1000000;
+
+const int MICROSECONDS_PER_SECOND = 1000000;
+const int NANOSECONDS_PER_MICROSECOND = 1000;
+
+inline void to_time(int milliseconds, boost::xtime& xt)
+{
+    int res = 0;
+    res = boost::xtime_get(&xt, boost::TIME_UTC);
+    BOOST_ASSERT(res == boost::TIME_UTC);
+
+    xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
+    xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) *
+        NANOSECONDS_PER_MILLISECOND);
+
+    if (xt.nsec >= NANOSECONDS_PER_SECOND)
+    {
+        ++xt.sec;
+        xt.nsec -= NANOSECONDS_PER_SECOND;
+    }
+}
+
+#if defined(BOOST_HAS_PTHREADS)
+inline void to_timespec(const boost::xtime& xt, timespec& ts)
+{
+    ts.tv_sec = static_cast<int>(xt.sec);
+    ts.tv_nsec = static_cast<int>(xt.nsec);
+    if(ts.tv_nsec >= NANOSECONDS_PER_SECOND)
+    {
+        ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
+        ts.tv_nsec %= NANOSECONDS_PER_SECOND;
+    }
+}
+
+inline void to_time(int milliseconds, timespec& ts)
+{
+    boost::xtime xt;
+    to_time(milliseconds, xt);
+    to_timespec(xt, ts);
+}
+
+inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
+{
+    boost::xtime cur;
+    int res = 0;
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
+    BOOST_ASSERT(res == boost::TIME_UTC);
+
+    if (boost::xtime_cmp(xt, cur) <= 0)
+    {
+        ts.tv_sec = 0;
+        ts.tv_nsec = 0;
+    }
+    else
+    {
+        ts.tv_sec = xt.sec - cur.sec;
+        ts.tv_nsec = xt.nsec - cur.nsec;
+
+        if( ts.tv_nsec < 0 )
+        {
+            ts.tv_sec -= 1;
+            ts.tv_nsec += NANOSECONDS_PER_SECOND;
+        }
+        if(ts.tv_nsec >= NANOSECONDS_PER_SECOND)
+        {
+            ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
+            ts.tv_nsec %= NANOSECONDS_PER_SECOND;
+        }
+    }
+}
+#endif
+
+inline void to_duration(boost::xtime xt, int& milliseconds)
+{
+    boost::xtime cur;
+    int res = 0;
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
+    BOOST_ASSERT(res == boost::TIME_UTC);
+
+    if (boost::xtime_cmp(xt, cur) <= 0)
+        milliseconds = 0;
+    else
+    {
+        if (cur.nsec > xt.nsec)
+        {
+            xt.nsec += NANOSECONDS_PER_SECOND;
+            --xt.sec;
+        }
+        milliseconds = (int)((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +
+            (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) /
+                NANOSECONDS_PER_MILLISECOND);
+    }
+}
+
+inline void to_microduration(boost::xtime xt, int& microseconds)
+{
+    boost::xtime cur;
+    int res = 0;
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
+    BOOST_ASSERT(res == boost::TIME_UTC);
+
+    if (boost::xtime_cmp(xt, cur) <= 0)
+        microseconds = 0;
+    else
+    {
+        if (cur.nsec > xt.nsec)
+        {
+            xt.nsec += NANOSECONDS_PER_SECOND;
+            --xt.sec;
+        }
+        microseconds = (int)((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) +
+            (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MICROSECOND/2)) /
+                NANOSECONDS_PER_MICROSECOND);
+    }
+}
+}
+
+// Change Log:
+//    1 Jun 01  Initial creation.

src/tss_null.cpp

@@ -0,0 +1,38 @@
+// (C) Copyright Michael Glassford 2004.
+// (C) Copyright 2007 Anthony Williams
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/config.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))
+
+namespace boost 
+{
+    /*
+    This file is a "null" implementation of tss cleanup; it's
+    purpose is to to eliminate link errors in cases
+    where it is known that tss cleanup is not needed.
+    */
+
+    void tss_cleanup_implemented(void)
+    {
+        /*
+        This function's sole purpose is to cause a link error in cases where
+        automatic tss cleanup is not implemented by Boost.Threads as a
+        reminder that user code is responsible for calling the necessary
+        functions at the appropriate times (and for implementing an a
+        tss_cleanup_implemented() function to eliminate the linker's
+        missing symbol error).
+
+        If Boost.Threads later implements automatic tss cleanup in cases
+        where it currently doesn't (which is the plan), the duplicate
+        symbol error will warn the user that their custom solution is no
+        longer needed and can be removed.
+        */
+    }
+	
+}
+
+#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)

src/win32/thread.cpp

@@ -0,0 +1,629 @@
+// 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 Anthony Williams
+// (C) Copyright 2007 David Deakins
+
+#define _WIN32_WINNT 0x400
+#define WINVER 0x400
+
+#include <boost/thread/thread.hpp>
+#include <algorithm>
+#ifndef UNDER_CE
+#include <process.h>
+#endif
+#include <stdio.h>
+#include <boost/thread/once.hpp>
+#include <boost/thread/tss.hpp>
+#include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/thread/detail/tss_hooks.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
+#include <windows.h>
+
+namespace boost
+{
+    namespace
+    {
+        boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
+        DWORD current_thread_tls_key=0;
+
+        void create_current_thread_tls_key()
+        {
+            tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in
+            current_thread_tls_key=TlsAlloc();
+			#if defined(UNDER_CE)
+				// Windows CE does not define the TLS_OUT_OF_INDEXES constant.
+				BOOST_ASSERT(current_thread_tls_key!=0xFFFFFFFF);
+			#else
+				BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);
+			#endif
+        }
+
+        void cleanup_tls_key()
+        {
+            if(current_thread_tls_key)
+            {
+                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;
+            }
+            return (detail::thread_data_base*)TlsGetValue(current_thread_tls_key);
+        }
+
+        void set_current_thread_data(detail::thread_data_base* new_data)
+        {
+            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
+            if(current_thread_tls_key)
+                BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
+            else
+                boost::throw_exception(thread_resource_error());
+        }
+
+#ifndef BOOST_HAS_THREADEX
+// Windows CE doesn't define _beginthreadex
+
+        struct ThreadProxyData
+        {
+            typedef unsigned (__stdcall* func)(void*);
+            func start_address_;
+            void* arglist_;
+            ThreadProxyData(func start_address,void* arglist) : start_address_(start_address), arglist_(arglist) {}
+        };
+
+        DWORD WINAPI ThreadProxy(LPVOID args)
+        {
+            ThreadProxyData* data=reinterpret_cast<ThreadProxyData*>(args);
+            DWORD ret=data->start_address_(data->arglist_);
+            delete data;
+            return ret;
+        }
+        
+        typedef void* uintptr_t;
+
+        inline uintptr_t const _beginthreadex(void* security, unsigned stack_size, unsigned (__stdcall* start_address)(void*),
+                                              void* arglist, unsigned initflag, unsigned* thrdaddr)
+        {
+            DWORD threadID;
+            HANDLE hthread=CreateThread(static_cast<LPSECURITY_ATTRIBUTES>(security),stack_size,ThreadProxy,
+                                        new ThreadProxyData(start_address,arglist),initflag,&threadID);
+            if (hthread!=0)
+                *thrdaddr=threadID;
+            return reinterpret_cast<uintptr_t const>(hthread);
+        }
+
+#endif
+
+    }
+
+    namespace detail
+    {
+        struct thread_exit_callback_node
+        {
+            boost::detail::thread_exit_function_base* func;
+            thread_exit_callback_node* next;
+
+            thread_exit_callback_node(boost::detail::thread_exit_function_base* func_,
+                                      thread_exit_callback_node* next_):
+                func(func_),next(next_)
+            {}
+        };
+
+        struct tss_data_node
+        {
+            void const* key;
+            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
+            void* value;
+            tss_data_node* next;
+
+            tss_data_node(void const* key_,boost::shared_ptr<boost::detail::tss_cleanup_function> func_,void* value_,
+                          tss_data_node* next_):
+                key(key_),func(func_),value(value_),next(next_)
+            {}
+        };
+
+    }
+
+    namespace
+    {
+        void run_thread_exit_callbacks()
+        {
+            detail::thread_data_ptr current_thread_data(get_current_thread_data(),false);
+            if(current_thread_data)
+            {
+                while(current_thread_data->tss_data || current_thread_data->thread_exit_callbacks)
+                {
+                    while(current_thread_data->thread_exit_callbacks)
+                    {
+                        detail::thread_exit_callback_node* const current_node=current_thread_data->thread_exit_callbacks;
+                        current_thread_data->thread_exit_callbacks=current_node->next;
+                        if(current_node->func)
+                        {
+                            (*current_node->func)();
+                            boost::detail::heap_delete(current_node->func);
+                        }
+                        boost::detail::heap_delete(current_node);
+                    }
+                    while(current_thread_data->tss_data)
+                    {
+                        detail::tss_data_node* const current_node=current_thread_data->tss_data;
+                        current_thread_data->tss_data=current_node->next;
+                        if(current_node->func)
+                        {
+                            (*current_node->func)(current_node->value);
+                        }
+                        boost::detail::heap_delete(current_node);
+                    }
+                }
+                
+                set_current_thread_data(0);
+            }
+        }
+        
+        unsigned __stdcall thread_start_function(void* param)
+        {
+            detail::thread_data_base* const thread_info(reinterpret_cast<detail::thread_data_base*>(param));
+            set_current_thread_data(thread_info);
+            try
+            {
+                thread_info->run();
+            }
+            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();
+//             }
+            run_thread_exit_callbacks();
+            return 0;
+        }
+    }
+
+    thread::thread()
+    {}
+
+    void thread::start_thread()
+    {
+        uintptr_t const new_thread=_beginthreadex(0,0,&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);
+        if(!new_thread)
+        {
+            boost::throw_exception(thread_resource_error());
+        }
+        intrusive_ptr_add_ref(thread_info.get());
+        thread_info->thread_handle=(detail::win32::handle)(new_thread);
+        ResumeThread(thread_info->thread_handle);
+    }
+
+    thread::thread(detail::thread_data_ptr data):
+        thread_info(data)
+    {}
+
+    namespace
+    {
+        struct externally_launched_thread:
+            detail::thread_data_base
+        {
+            externally_launched_thread()
+            {
+                ++count;
+                interruption_enabled=false;
+            }
+            
+            void run()
+            {}
+        private:
+            externally_launched_thread(externally_launched_thread&);
+            void operator=(externally_launched_thread&);
+        };
+
+        void make_external_thread_data()
+        {
+            externally_launched_thread* me=detail::heap_new<externally_launched_thread>();
+            try
+            {
+                set_current_thread_data(me);
+            }
+            catch(...)
+            {
+                detail::heap_delete(me);
+                throw;
+            }
+        }
+
+        detail::thread_data_base* get_or_make_current_thread_data()
+        {
+            detail::thread_data_base* current_thread_data(get_current_thread_data());
+            if(!current_thread_data)
+            {
+                make_external_thread_data();
+                current_thread_data=get_current_thread_data();
+            }
+            return current_thread_data;
+        }
+        
+    }
+
+    thread::~thread()
+    {
+        detach();
+    }
+    
+    thread::id thread::get_id() const
+    {
+        return thread::id((get_thread_info)());
+    }
+
+    bool thread::joinable() const
+    {
+        return (get_thread_info)();
+    }
+
+    void thread::join()
+    {
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            this_thread::interruptible_wait(local_thread_info->thread_handle,detail::timeout::sentinel());
+            release_handle();
+        }
+    }
+
+    bool thread::timed_join(boost::system_time const& wait_until)
+    {
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            if(!this_thread::interruptible_wait(local_thread_info->thread_handle,get_milliseconds_until(wait_until)))
+            {
+                return false;
+            }
+            release_handle();
+        }
+        return true;
+    }
+    
+    void thread::detach()
+    {
+        release_handle();
+    }
+
+    void thread::release_handle()
+    {
+        thread_info=0;
+    }
+    
+    void thread::interrupt()
+    {
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
+        if(local_thread_info)
+        {
+            local_thread_info->interrupt();
+        }
+    }
+    
+    bool thread::interruption_requested() const
+    {
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
+        return local_thread_info.get() && (detail::win32::WaitForSingleObject(local_thread_info->interruption_handle,0)==0);
+    }
+    
+    unsigned thread::hardware_concurrency()
+    {
+        SYSTEM_INFO info={{0}};
+        GetSystemInfo(&info);
+        return info.dwNumberOfProcessors;
+    }
+    
+    thread::native_handle_type thread::native_handle()
+    {
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
+        return local_thread_info?(detail::win32::handle)local_thread_info->thread_handle:detail::win32::invalid_handle_value;
+    }
+
+    detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    {
+        return thread_info;
+    }
+
+    namespace this_thread
+    {
+        namespace
+        {
+            LARGE_INTEGER get_due_time(detail::timeout const&  target_time)
+            {
+                LARGE_INTEGER due_time={{0}};
+                if(target_time.relative)
+                {
+                    unsigned long const elapsed_milliseconds=GetTickCount()-target_time.start;
+                    LONGLONG const remaining_milliseconds=(target_time.milliseconds-elapsed_milliseconds);
+                    LONGLONG const hundred_nanoseconds_in_one_millisecond=10000;
+
+                    if(remaining_milliseconds>0)
+                    {
+                        due_time.QuadPart=-(remaining_milliseconds*hundred_nanoseconds_in_one_millisecond);
+                    }
+                }
+                else
+                {
+                    SYSTEMTIME target_system_time={0};
+                    target_system_time.wYear=target_time.abs_time.date().year();
+                    target_system_time.wMonth=target_time.abs_time.date().month();
+                    target_system_time.wDay=target_time.abs_time.date().day();
+                    target_system_time.wHour=(WORD)target_time.abs_time.time_of_day().hours();
+                    target_system_time.wMinute=(WORD)target_time.abs_time.time_of_day().minutes();
+                    target_system_time.wSecond=(WORD)target_time.abs_time.time_of_day().seconds();
+
+                    if(!SystemTimeToFileTime(&target_system_time,((FILETIME*)&due_time)))
+                    {
+                        due_time.QuadPart=0;
+                    }
+                    else
+                    {
+                        long const hundred_nanoseconds_in_one_second=10000000;
+                        posix_time::time_duration::tick_type const ticks_per_second=
+                            target_time.abs_time.time_of_day().ticks_per_second();
+                        if(ticks_per_second>hundred_nanoseconds_in_one_second)
+                        {
+                            posix_time::time_duration::tick_type const 
+                                ticks_per_hundred_nanoseconds=
+                                ticks_per_second/hundred_nanoseconds_in_one_second;
+                            due_time.QuadPart+=
+                                target_time.abs_time.time_of_day().fractional_seconds()/
+                                ticks_per_hundred_nanoseconds;
+                        }
+                        else
+                        {
+                            due_time.QuadPart+=
+                                target_time.abs_time.time_of_day().fractional_seconds()*
+                                (hundred_nanoseconds_in_one_second/ticks_per_second);
+                        }
+                    }
+                }
+                return due_time;
+            }
+        }
+        
+
+        bool interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time)
+        {
+            detail::win32::handle handles[3]={0};
+            unsigned handle_count=0;
+            unsigned wait_handle_index=~0U;
+            unsigned interruption_index=~0U;
+            unsigned timeout_index=~0U;
+            if(handle_to_wait_for!=detail::win32::invalid_handle_value)
+            {
+                wait_handle_index=handle_count;
+                handles[handle_count++]=handle_to_wait_for;
+            }
+            if(get_current_thread_data() && get_current_thread_data()->interruption_enabled)
+            {
+                interruption_index=handle_count;
+                handles[handle_count++]=get_current_thread_data()->interruption_handle;
+            }
+
+            detail::win32::handle_manager timer_handle;
+            
+#ifndef UNDER_CE
+            unsigned const min_timer_wait_period=20;
+            
+            if(!target_time.is_sentinel())
+            {
+                detail::timeout::remaining_time const time_left=target_time.remaining_milliseconds();
+                if(time_left.milliseconds > min_timer_wait_period)
+                {
+                    // for a long-enough timeout, use a waitable timer (which tracks clock changes)
+                    timer_handle=CreateWaitableTimer(NULL,false,NULL);
+                    if(timer_handle!=0)
+                    {
+                        LARGE_INTEGER due_time=get_due_time(target_time);
+                        
+                        bool const set_time_succeeded=SetWaitableTimer(timer_handle,&due_time,0,0,0,false)!=0;
+                        if(set_time_succeeded)
+                        {
+                            timeout_index=handle_count;
+                            handles[handle_count++]=timer_handle;
+                        }
+                    }
+                }
+                else if(!target_time.relative)
+                {
+                    // convert short absolute-time timeouts into relative ones, so we don't race against clock changes
+                    target_time=detail::timeout(time_left.milliseconds);
+                }
+            }
+#endif
+        
+            bool const using_timer=timeout_index!=~0u;
+            detail::timeout::remaining_time time_left(0);
+            
+            do
+            {
+                if(!using_timer)
+                {
+                    time_left=target_time.remaining_milliseconds();
+                }
+                
+                if(handle_count)
+                {
+                    unsigned long const notified_index=detail::win32::WaitForMultipleObjects(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds);
+                    if(notified_index<handle_count)
+                    {
+                        if(notified_index==wait_handle_index)
+                        {
+                            return true;
+                        }
+                        else if(notified_index==interruption_index)
+                        {
+                            detail::win32::ResetEvent(get_current_thread_data()->interruption_handle);
+                            throw thread_interrupted();
+                        }
+                        else if(notified_index==timeout_index)
+                        {
+                            return false;
+                        }
+                    }
+                }
+                else
+                {
+                    detail::win32::Sleep(time_left.milliseconds);
+                }
+                if(target_time.relative)
+                {
+                    target_time.milliseconds-=detail::timeout::max_non_infinite_wait;
+                }
+            }
+            while(time_left.more);
+            return false;
+        }
+
+        thread::id get_id()
+        {
+            return thread::id(get_or_make_current_thread_data());
+        }
+
+        void interruption_point()
+        {
+            if(interruption_enabled() && interruption_requested())
+            {
+                detail::win32::ResetEvent(get_current_thread_data()->interruption_handle);
+                throw thread_interrupted();
+            }
+        }
+        
+        bool interruption_enabled()
+        {
+            return get_current_thread_data() && get_current_thread_data()->interruption_enabled;
+        }
+        
+        bool interruption_requested()
+        {
+            return get_current_thread_data() && (detail::win32::WaitForSingleObject(get_current_thread_data()->interruption_handle,0)==0);
+        }
+
+        void yield()
+        {
+            detail::win32::Sleep(0);
+        }
+        
+        disable_interruption::disable_interruption():
+            interruption_was_enabled(interruption_enabled())
+        {
+            if(interruption_was_enabled)
+            {
+                get_current_thread_data()->interruption_enabled=false;
+            }
+        }
+        
+        disable_interruption::~disable_interruption()
+        {
+            if(get_current_thread_data())
+            {
+                get_current_thread_data()->interruption_enabled=interruption_was_enabled;
+            }
+        }
+
+        restore_interruption::restore_interruption(disable_interruption& d)
+        {
+            if(d.interruption_was_enabled)
+            {
+                get_current_thread_data()->interruption_enabled=true;
+            }
+        }
+        
+        restore_interruption::~restore_interruption()
+        {
+            if(get_current_thread_data())
+            {
+                get_current_thread_data()->interruption_enabled=false;
+            }
+        }
+    }
+
+    namespace detail
+    {
+        void add_thread_exit_function(thread_exit_function_base* func)
+        {
+            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
+            thread_exit_callback_node* const new_node=
+                heap_new<thread_exit_callback_node>(
+                    func,current_thread_data->thread_exit_callbacks);
+            current_thread_data->thread_exit_callbacks=new_node;
+        }
+
+        tss_data_node* find_tss_data(void const* key)
+        {
+            detail::thread_data_base* const current_thread_data(get_current_thread_data());
+            if(current_thread_data)
+            {
+                detail::tss_data_node* current_node=current_thread_data->tss_data;
+                while(current_node)
+                {
+                    if(current_node->key==key)
+                    {
+                        return current_node;
+                    }
+                    current_node=current_node->next;
+                }
+            }
+            return NULL;
+        }
+
+        void* get_tss_data(void const* key)
+        {
+            if(tss_data_node* const current_node=find_tss_data(key))
+            {
+                return current_node->value;
+            }
+            return NULL;
+        }
+        
+        void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing)
+        {
+            if(tss_data_node* const current_node=find_tss_data(key))
+            {
+                if(cleanup_existing && current_node->func.get() && current_node->value)
+                {
+                    (*current_node->func)(current_node->value);
+                }
+                current_node->func=func;
+                current_node->value=tss_data;
+            }
+            else if(func && tss_data)
+            {
+                detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
+                tss_data_node* const new_node=
+                    heap_new<tss_data_node>(key,func,tss_data,current_thread_data->tss_data);
+                current_thread_data->tss_data=new_node;
+            }
+        }
+    }
+    BOOST_THREAD_DECL void __cdecl on_process_enter()
+    {}
+
+    BOOST_THREAD_DECL void __cdecl on_thread_enter()
+    {}
+
+    BOOST_THREAD_DECL void __cdecl on_process_exit()
+    {
+        boost::cleanup_tls_key();
+    }
+
+    BOOST_THREAD_DECL void __cdecl on_thread_exit()
+    {
+        boost::run_thread_exit_callbacks();
+    }
+
+}
+
+

src/win32/timeconv.inl

@@ -0,0 +1,130 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// boostinspect:nounnamed
+
+namespace {
+const int MILLISECONDS_PER_SECOND = 1000;
+const int NANOSECONDS_PER_SECOND = 1000000000;
+const int NANOSECONDS_PER_MILLISECOND = 1000000;
+
+const int MICROSECONDS_PER_SECOND = 1000000;
+const int NANOSECONDS_PER_MICROSECOND = 1000;
+
+inline void to_time(int milliseconds, boost::xtime& xt)
+{
+    int res = 0;
+    res = boost::xtime_get(&xt, boost::TIME_UTC);
+    assert(res == boost::TIME_UTC);
+
+    xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
+    xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) *
+        NANOSECONDS_PER_MILLISECOND);
+
+    if (xt.nsec >= NANOSECONDS_PER_SECOND)
+    {
+        ++xt.sec;
+        xt.nsec -= NANOSECONDS_PER_SECOND;
+    }
+}
+
+#if defined(BOOST_HAS_PTHREADS)
+inline void to_timespec(const boost::xtime& xt, timespec& ts)
+{
+    ts.tv_sec = static_cast<int>(xt.sec);
+    ts.tv_nsec = static_cast<int>(xt.nsec);
+    if(ts.tv_nsec >= NANOSECONDS_PER_SECOND)
+    {
+        ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
+        ts.tv_nsec %= NANOSECONDS_PER_SECOND;
+    }
+}
+
+inline void to_time(int milliseconds, timespec& ts)
+{
+    boost::xtime xt;
+    to_time(milliseconds, xt);
+    to_timespec(xt, ts);
+}
+
+inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
+{
+    boost::xtime cur;
+    int res = 0;
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
+    assert(res == boost::TIME_UTC);
+
+    if (boost::xtime_cmp(xt, cur) <= 0)
+    {
+        ts.tv_sec = 0;
+        ts.tv_nsec = 0;
+    }
+    else
+    {
+        ts.tv_sec = xt.sec - cur.sec;
+        ts.tv_nsec = xt.nsec - cur.nsec;
+
+        if( ts.tv_nsec < 0 )
+        {
+            ts.tv_sec -= 1;
+            ts.tv_nsec += NANOSECONDS_PER_SECOND;
+        }
+        if(ts.tv_nsec >= NANOSECONDS_PER_SECOND)
+        {
+            ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
+            ts.tv_nsec %= NANOSECONDS_PER_SECOND;
+        }
+    }
+}
+#endif
+
+inline void to_duration(boost::xtime xt, int& milliseconds)
+{
+    boost::xtime cur;
+    int res = 0;
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
+    assert(res == boost::TIME_UTC);
+
+    if (boost::xtime_cmp(xt, cur) <= 0)
+        milliseconds = 0;
+    else
+    {
+        if (cur.nsec > xt.nsec)
+        {
+            xt.nsec += NANOSECONDS_PER_SECOND;
+            --xt.sec;
+        }
+        milliseconds = (int)((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +
+            (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) /
+                NANOSECONDS_PER_MILLISECOND);
+    }
+}
+
+inline void to_microduration(boost::xtime xt, int& microseconds)
+{
+    boost::xtime cur;
+    int res = 0;
+    res = boost::xtime_get(&cur, boost::TIME_UTC);
+    assert(res == boost::TIME_UTC);
+
+    if (boost::xtime_cmp(xt, cur) <= 0)
+        microseconds = 0;
+    else
+    {
+        if (cur.nsec > xt.nsec)
+        {
+            xt.nsec += NANOSECONDS_PER_SECOND;
+            --xt.sec;
+        }
+        microseconds = (int)((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) +
+            (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MICROSECOND/2)) /
+                NANOSECONDS_PER_MICROSECOND);
+    }
+}
+}
+
+// Change Log:
+//    1 Jun 01  Initial creation.

src/win32/tss_dll.cpp

@@ -0,0 +1,76 @@
+// (C) Copyright Michael Glassford 2004.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/config.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)
+
+    #include <boost/thread/detail/tss_hooks.hpp>
+
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+
+    #if defined(__BORLANDC__)
+        extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+    #elif defined(_WIN32_WCE)
+        extern "C" BOOL WINAPI DllMain(HANDLE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+    #else
+        extern "C" BOOL WINAPI DllMain(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+    #endif
+    {
+        switch(dwReason)
+        {
+            case DLL_PROCESS_ATTACH:
+            {
+                boost::on_process_enter();
+                boost::on_thread_enter();
+                break;
+            }
+
+            case DLL_THREAD_ATTACH:
+            {
+                boost::on_thread_enter();
+                break;
+            }
+
+            case DLL_THREAD_DETACH:
+            {
+                boost::on_thread_exit();
+                break;
+            }
+
+            case DLL_PROCESS_DETACH:
+            {
+                boost::on_thread_exit();
+                boost::on_process_exit();
+                break;
+            }
+        }
+
+        return TRUE;
+    }
+
+namespace boost
+{
+    void tss_cleanup_implemented()
+    {
+        /*
+        This function's sole purpose is to cause a link error in cases where
+        automatic tss cleanup is not implemented by Boost.Threads as a
+        reminder that user code is responsible for calling the necessary
+        functions at the appropriate times (and for implementing an a
+        tss_cleanup_implemented() function to eliminate the linker's
+        missing symbol error).
+
+        If Boost.Threads later implements automatic tss cleanup in cases
+        where it currently doesn't (which is the plan), the duplicate
+        symbol error will warn the user that their custom solution is no
+        longer needed and can be removed.
+        */
+    }
+}
+
+
+#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)

src/win32/tss_pe.cpp

@@ -0,0 +1,284 @@
+// $Id$
+// (C) Copyright Aaron W. LaFramboise, Roland Schwarz, Michael Glassford 2004.
+// (C) Copyright 2007 Roland Schwarz
+// (C) Copyright 2007 Anthony Williams
+// (C) Copyright 2007 David Deakins
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/config.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) 
+
+#if (defined(__MINGW32__) && !defined(_WIN64)) || defined(__MINGW64__)
+
+#include <boost/thread/detail/tss_hooks.hpp>
+
+#include <windows.h>
+
+#include <cstdlib>
+
+namespace boost
+{
+    void tss_cleanup_implemented() {}
+}
+
+namespace {
+    void NTAPI on_tls_callback(void* h, DWORD dwReason, PVOID pv)
+    {
+        switch (dwReason)
+        {
+        case DLL_THREAD_DETACH:
+        {
+            boost::on_thread_exit();
+            break;
+        }
+        }
+    }
+}
+
+#if defined(__MINGW64__) || (__MINGW32_MAJOR_VERSION >3) ||             \
+    ((__MINGW32_MAJOR_VERSION==3) && (__MINGW32_MINOR_VERSION>=18))
+extern "C"
+{
+    PIMAGE_TLS_CALLBACK __crt_xl_tls_callback__ __attribute__ ((section(".CRT$XLB"))) = on_tls_callback;
+}
+#else
+extern "C" {
+
+    void (* after_ctors )() __attribute__((section(".ctors")))     = boost::on_process_enter;
+    void (* before_dtors)() __attribute__((section(".dtors")))     = boost::on_thread_exit;
+    void (* after_dtors )() __attribute__((section(".dtors.zzz"))) = boost::on_process_exit;
+
+    ULONG __tls_index__ = 0;
+    char __tls_end__ __attribute__((section(".tls$zzz"))) = 0;
+    char __tls_start__ __attribute__((section(".tls"))) = 0;
+
+
+    PIMAGE_TLS_CALLBACK __crt_xl_start__ __attribute__ ((section(".CRT$XLA"))) = 0;
+    PIMAGE_TLS_CALLBACK __crt_xl_end__ __attribute__ ((section(".CRT$XLZ"))) = 0;
+}
+extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata$T"))) =
+{
+        (DWORD) &__tls_start__,
+        (DWORD) &__tls_end__,
+        (DWORD) &__tls_index__,
+        (DWORD) (&__crt_xl_start__+1),
+        (DWORD) 0,
+        (DWORD) 0
+};
+#endif
+
+
+#elif  defined(_MSC_VER) && !defined(UNDER_CE)
+
+    #include <boost/thread/detail/tss_hooks.hpp>
+
+    #include <stdlib.h>
+
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+
+    //Definitions required by implementation
+
+    #if (_MSC_VER < 1300) // 1300 == VC++ 7.0
+        typedef void (__cdecl *_PVFV)();
+        #define INIRETSUCCESS
+        #define PVAPI void __cdecl
+    #else
+        typedef int (__cdecl *_PVFV)();
+        #define INIRETSUCCESS 0
+        #define PVAPI int __cdecl
+    #endif
+
+    typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);
+
+    //Symbols for connection to the runtime environment
+
+    extern "C"
+    {
+        extern DWORD _tls_used; //the tls directory (located in .rdata segment)
+        extern _TLSCB __xl_a[], __xl_z[];    //tls initializers */
+    }
+
+    namespace
+    {
+        //Forward declarations
+
+        static PVAPI on_tls_prepare();
+        static PVAPI on_process_init();
+        static PVAPI on_process_term();
+        static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);
+
+        //The .CRT$Xxx information is taken from Codeguru:
+        //http://www.codeguru.com/Cpp/misc/misc/threadsprocesses/article.php/c6945__2/
+
+#if (_MSC_VER >= 1400)
+#pragma section(".CRT$XIU",long,read)
+#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;
+#else
+        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
+        #   pragma data_seg(push, old_seg)
+        #endif
+            //Callback to run tls glue code first.
+            //I don't think it is necessary to run it
+            //at .CRT$XIB level, since we are only
+            //interested in thread detachement. But
+            //this could be changed easily if required.
+
+            #pragma data_seg(".CRT$XIU")
+            static _PVFV p_tls_prepare = on_tls_prepare;
+            #pragma data_seg()
+
+            //Callback after all global ctors.
+
+            #pragma data_seg(".CRT$XCU")
+            static _PVFV p_process_init = on_process_init;
+            #pragma data_seg()
+
+            //Callback for tls notifications.
+
+            #pragma data_seg(".CRT$XLB")
+            _TLSCB p_thread_callback = on_tls_callback;
+            #pragma data_seg()
+            //Callback for termination.
+
+            #pragma data_seg(".CRT$XTU")
+            static _PVFV p_process_term = on_process_term;
+            #pragma data_seg()
+        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
+        #   pragma data_seg(pop, old_seg)
+        #endif
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4189)
+#endif
+
+        PVAPI on_tls_prepare()
+        {
+            //The following line has an important side effect:
+            //if the TLS directory is not already there, it will
+            //be created by the linker. In other words, it forces a tls
+            //directory to be generated by the linker even when static tls
+            //(i.e. __declspec(thread)) is not used.
+            //The volatile should prevent the optimizer
+            //from removing the reference.
+
+            DWORD volatile dw = _tls_used;
+
+            #if (_MSC_VER < 1300) // 1300 == VC++ 7.0
+                _TLSCB* pfbegin = __xl_a;
+                _TLSCB* pfend = __xl_z;
+                _TLSCB* pfdst = pfbegin;
+                //pfdst = (_TLSCB*)_tls_used.AddressOfCallBacks;
+
+                //The following loop will merge the address pointers
+                //into a contiguous area, since the tlssup code seems
+                //to require this (at least on MSVC 6)
+
+                while (pfbegin < pfend)
+                {
+                    if (*pfbegin != 0)
+                    {
+                        *pfdst = *pfbegin;
+                        ++pfdst;
+                    }
+                    ++pfbegin;
+                }
+
+                *pfdst = 0;
+            #endif
+
+            return INIRETSUCCESS;
+        }
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+        PVAPI on_process_init()
+        {
+            //Schedule on_thread_exit() to be called for the main
+            //thread before destructors of global objects have been
+            //called.
+
+            //It will not be run when 'quick' exiting the
+            //library; however, this is the standard behaviour
+            //for destructors of global objects, so that
+            //shouldn't be a problem.
+
+            atexit(boost::on_thread_exit);
+
+            //Call Boost process entry callback here
+
+            boost::on_process_enter();
+
+            return INIRETSUCCESS;
+        }
+
+        PVAPI on_process_term()
+        {
+            boost::on_process_exit();
+            return INIRETSUCCESS;
+        }
+
+        void NTAPI on_tls_callback(HINSTANCE /*h*/, DWORD dwReason, PVOID /*pv*/)
+        {
+            switch (dwReason)
+            {
+            case DLL_THREAD_DETACH:
+                boost::on_thread_exit();
+                break;
+            }
+        }
+
+        BOOL WINAPI dll_callback(HANDLE, DWORD dwReason, LPVOID)
+        {
+            switch (dwReason)
+            {
+            case DLL_THREAD_DETACH:
+                boost::on_thread_exit();
+                break;
+            case DLL_PROCESS_DETACH:
+                boost::on_process_exit();
+                break;
+            }
+            return true;
+        }
+    } //namespace
+
+extern "C"
+{
+    extern BOOL (WINAPI * const _pRawDllMain)(HANDLE, DWORD, LPVOID)=&dll_callback;
+}
+namespace boost
+{
+    void tss_cleanup_implemented()
+    {
+        /*
+        This function's sole purpose is to cause a link error in cases where
+        automatic tss cleanup is not implemented by Boost.Threads as a
+        reminder that user code is responsible for calling the necessary
+        functions at the appropriate times (and for implementing an a
+        tss_cleanup_implemented() function to eliminate the linker's
+        missing symbol error).
+
+        If Boost.Threads later implements automatic tss cleanup in cases
+        where it currently doesn't (which is the plan), the duplicate
+        symbol error will warn the user that their custom solution is no
+        longer needed and can be removed.
+        */
+    }
+}
+
+#endif //defined(_MSC_VER) && !defined(UNDER_CE)
+
+#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)

test/Carbon.r

@@ -0,0 +1,18 @@
+/*
+ *  Permit this Carbon application to launch on OS X
+ *
+ *  © 1997-2000 Metrowerks Corp.
+ *
+ *  Questions and comments to:
+ *       <mailto:support@metrowerks.com>
+ *       <http://www.metrowerks.com/>
+ */
+
+
+/*----------------------------carb ¥ Carbon on OS X launch information --------------------------*/
+type 'carb' {
+};
+
+
+resource 'carb'(0) {
+};

test/Jamfile.v2

@@ -0,0 +1,65 @@
+#  (C) Copyright William E. Kempf 2001. 
+#  (C) Copyright 2007 Anthony Williams. 
+#  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+#  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# Boost.Threads test Jamfile
+#
+# Additional configuration variables used:
+#   1. PTW32 may be used on Win32 platforms to specify that the pthreads-win32
+#      library should be used instead of "native" threads. This feature is
+#      mostly used for testing and it's generally recommended you use the
+#      native threading libraries instead. PTW32 should be set to be a list
+#      of two strings, the first specifying the installation path of the
+#      pthreads-win32 library and the second specifying which library
+#      variant to link against (see the pthreads-win32 documentation).
+#      Example: jam -sPTW32="c:\pthreads-win32 pthreadVCE.lib"
+
+# bring in rules for testing
+import testing ;
+
+project
+    : requirements <library>/boost/test//boost_unit_test_framework/<link>static
+                   <threading>multi
+    ;
+
+rule thread-run ( sources )
+{
+    return 
+    [ run $(sources) ../build//boost_thread ]
+    [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/<link>static 
+        : : : : $(sources[1]:B)_lib ]
+    ;
+}    
+
+{
+    test-suite "threads"
+        : [ thread-run test_thread.cpp ]
+          [ thread-run test_thread_id.cpp ]
+          [ thread-run test_hardware_concurrency.cpp ]
+          [ thread-run test_thread_move.cpp ]
+          [ thread-run test_thread_return_local.cpp ]
+          [ thread-run test_thread_move_return.cpp ]
+          [ thread-run test_thread_launching.cpp ]
+          [ thread-run test_thread_mf.cpp ]
+          [ thread-run test_thread_exit.cpp ]
+          [ thread-run test_move_function.cpp ]
+          [ thread-run test_mutex.cpp ]
+          [ thread-run test_condition_notify_one.cpp ]
+          [ thread-run test_condition_timed_wait_times_out.cpp ]
+          [ thread-run test_condition_notify_all.cpp ]
+          [ thread-run test_condition.cpp ]
+          [ thread-run test_tss.cpp ]
+          [ thread-run test_once.cpp ]
+          [ thread-run test_xtime.cpp ]
+          [ thread-run test_barrier.cpp ]
+          [ thread-run test_shared_mutex.cpp ]
+          [ thread-run test_shared_mutex_part_2.cpp ]
+          [ thread-run test_shared_mutex_timed_locks.cpp ]
+          [ thread-run test_lock_concept.cpp ]
+          [ thread-run test_generic_locks.cpp ]
+          [ thread-run test_futures.cpp ]
+          [ compile-fail no_implicit_move_from_lvalue_thread.cpp ]
+          [ compile-fail no_implicit_assign_from_lvalue_thread.cpp ]
+    ;
+}

test/condition_test_common.hpp

@@ -0,0 +1,97 @@
+#ifndef CONDITION_TEST_COMMON_HPP
+#define CONDITION_TEST_COMMON_HPP
+// 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)
+
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread_time.hpp>
+
+unsigned const timeout_seconds=5;
+    
+struct wait_for_flag
+{
+    boost::mutex mutex;
+    boost::condition_variable cond_var;
+    bool flag;
+    unsigned woken;
+        
+    wait_for_flag():
+        flag(false),woken(0)
+    {}
+
+    struct check_flag
+    {
+        bool const& flag;
+            
+        check_flag(bool const& flag_):
+            flag(flag_)
+        {}
+            
+        bool operator()() const
+        {
+            return flag;
+        }
+    private:
+        void operator=(check_flag&);
+    };
+
+        
+    void wait_without_predicate()
+    {
+        boost::mutex::scoped_lock lock(mutex);
+        while(!flag)
+        {
+            cond_var.wait(lock);
+        }
+        ++woken;
+    }
+
+    void wait_with_predicate()
+    {
+        boost::mutex::scoped_lock lock(mutex);
+        cond_var.wait(lock,check_flag(flag));
+        if(flag)
+        {
+            ++woken;
+        }
+    }
+
+    void timed_wait_without_predicate()
+    {
+        boost::system_time const timeout=boost::get_system_time()+boost::posix_time::seconds(timeout_seconds);
+            
+        boost::mutex::scoped_lock lock(mutex);
+        while(!flag)
+        {
+            if(!cond_var.timed_wait(lock,timeout))
+            {
+                return;
+            }
+        }
+        ++woken;
+    }
+
+    void timed_wait_with_predicate()
+    {
+        boost::system_time const timeout=boost::get_system_time()+boost::posix_time::seconds(timeout_seconds);
+        boost::mutex::scoped_lock lock(mutex);
+        if(cond_var.timed_wait(lock,timeout,check_flag(flag)) && flag)
+        {
+            ++woken;
+        }
+    }
+    void relative_timed_wait_with_predicate()
+    {
+        boost::mutex::scoped_lock lock(mutex);
+        if(cond_var.timed_wait(lock,boost::posix_time::seconds(timeout_seconds),check_flag(flag)) && flag)
+        {
+            ++woken;
+        }
+    }
+};
+
+
+#endif

test/no_implicit_assign_from_lvalue_thread.cpp

@@ -0,0 +1,15 @@
+// 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)
+#include <boost/thread/thread.hpp>
+
+void do_nothing()
+{}
+
+void test()
+{
+    boost::thread t1(do_nothing);
+    boost::thread t2;
+    t2=t1;
+}

test/no_implicit_move_from_lvalue_thread.cpp

@@ -0,0 +1,14 @@
+// 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)
+#include <boost/thread/thread.hpp>
+
+void do_nothing()
+{}
+
+void test()
+{
+    boost::thread t1(do_nothing);
+    boost::thread t2(t1);
+}

test/shared_mutex_locking_thread.hpp

@@ -0,0 +1,132 @@
+#ifndef SHARED_MUTEX_LOCKING_THREAD_HPP
+#define SHARED_MUTEX_LOCKING_THREAD_HPP
+
+//  (C) Copyright 2008 Anthony Williams
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+template<typename lock_type>
+class locking_thread
+{
+    boost::shared_mutex& rw_mutex;
+    unsigned& unblocked_count;
+    boost::condition_variable& unblocked_condition;
+    unsigned& simultaneous_running_count;
+    unsigned& max_simultaneous_running;
+    boost::mutex& unblocked_count_mutex;
+    boost::mutex& finish_mutex;
+public:
+    locking_thread(boost::shared_mutex& rw_mutex_,
+                   unsigned& unblocked_count_,
+                   boost::mutex& unblocked_count_mutex_,
+                   boost::condition_variable& unblocked_condition_,
+                   boost::mutex& finish_mutex_,
+                   unsigned& simultaneous_running_count_,
+                   unsigned& max_simultaneous_running_):
+        rw_mutex(rw_mutex_),
+        unblocked_count(unblocked_count_),
+        unblocked_condition(unblocked_condition_),
+        simultaneous_running_count(simultaneous_running_count_),
+        max_simultaneous_running(max_simultaneous_running_),
+        unblocked_count_mutex(unblocked_count_mutex_),
+        finish_mutex(finish_mutex_)
+    {}
+        
+    void operator()()
+    {
+        // acquire lock
+        lock_type lock(rw_mutex);
+            
+        // increment count to show we're unblocked
+        {
+            boost::mutex::scoped_lock ublock(unblocked_count_mutex);
+            ++unblocked_count;
+            unblocked_condition.notify_one();
+            ++simultaneous_running_count;
+            if(simultaneous_running_count>max_simultaneous_running)
+            {
+                max_simultaneous_running=simultaneous_running_count;
+            }
+        }
+            
+        // wait to finish
+        boost::mutex::scoped_lock finish_lock(finish_mutex);
+        {
+            boost::mutex::scoped_lock ublock(unblocked_count_mutex);
+            --simultaneous_running_count;
+        }
+    }
+private:
+    void operator=(locking_thread&);
+};
+
+class simple_writing_thread
+{
+    boost::shared_mutex& rwm;
+    boost::mutex& finish_mutex;
+    boost::mutex& unblocked_mutex;
+    unsigned& unblocked_count;
+        
+    void operator=(simple_writing_thread&);
+        
+public:
+    simple_writing_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::unique_lock<boost::shared_mutex>  lk(rwm);
+            
+        {
+            boost::mutex::scoped_lock ulk(unblocked_mutex);
+            ++unblocked_count;
+        }
+            
+        boost::mutex::scoped_lock flk(finish_mutex);
+    }
+};
+
+class simple_reading_thread
+{
+    boost::shared_mutex& rwm;
+    boost::mutex& finish_mutex;
+    boost::mutex& unblocked_mutex;
+    unsigned& unblocked_count;
+        
+    void operator=(simple_reading_thread&);
+        
+public:
+    simple_reading_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::shared_lock<boost::shared_mutex>  lk(rwm);
+            
+        {
+            boost::mutex::scoped_lock ulk(unblocked_mutex);
+            ++unblocked_count;
+        }
+            
+        boost::mutex::scoped_lock flk(finish_mutex);
+    }
+};
+
+
+#endif

test/test_barrier.cpp

@@ -0,0 +1,66 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/thread.hpp>
+#include <boost/thread/barrier.hpp>
+
+#include <boost/test/unit_test.hpp>
+#include <vector>
+
+namespace {
+
+// Shared variables for generation barrier test
+const int N_THREADS=10;
+boost::barrier gen_barrier(N_THREADS);
+boost::mutex mutex;
+long global_parameter;
+
+void barrier_thread()
+{
+    for (int i = 0; i < 5; ++i)
+    {
+        if (gen_barrier.wait())
+        {
+            boost::mutex::scoped_lock lock(mutex);
+            global_parameter++;
+        }
+    }
+}
+
+} // namespace
+
+void test_barrier()
+{
+    boost::thread_group g;
+    global_parameter = 0;
+
+    try
+    {
+        for (int i = 0; i < N_THREADS; ++i)
+            g.create_thread(&barrier_thread);
+        g.join_all();
+    }
+    catch(...)
+    {
+        g.interrupt_all();
+        g.join_all();
+        throw;
+    }
+    
+    BOOST_CHECK_EQUAL(global_parameter,5);
+}
+
+boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Threads: barrier test suite");
+
+    test->add(BOOST_TEST_CASE(&test_barrier));
+
+    return test;
+}

test/test_condition.cpp

@@ -0,0 +1,190 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+// 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/xtime.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#include <libs/thread/test/util.inl>
+
+struct condition_test_data
+{
+    condition_test_data() : notified(0), awoken(0) { }
+
+    boost::mutex mutex;
+    boost::condition_variable condition;
+    int notified;
+    int awoken;
+};
+
+void condition_test_thread(condition_test_data* data)
+{
+    boost::mutex::scoped_lock lock(data->mutex);
+    BOOST_CHECK(lock ? true : false);
+    while (!(data->notified > 0))
+        data->condition.wait(lock);
+    BOOST_CHECK(lock ? true : false);
+    data->awoken++;
+}
+
+struct cond_predicate
+{
+    cond_predicate(int& var, int val) : _var(var), _val(val) { }
+
+    bool operator()() { return _var == _val; }
+
+    int& _var;
+    int _val;
+private:
+    void operator=(cond_predicate&);
+    
+};
+
+void condition_test_waits(condition_test_data* data)
+{
+    boost::mutex::scoped_lock lock(data->mutex);
+    BOOST_CHECK(lock ? true : false);
+
+    // Test wait.
+    while (data->notified != 1)
+        data->condition.wait(lock);
+    BOOST_CHECK(lock ? true : false);
+    BOOST_CHECK_EQUAL(data->notified, 1);
+    data->awoken++;
+    data->condition.notify_one();
+
+    // Test predicate wait.
+    data->condition.wait(lock, cond_predicate(data->notified, 2));
+    BOOST_CHECK(lock ? true : false);
+    BOOST_CHECK_EQUAL(data->notified, 2);
+    data->awoken++;
+    data->condition.notify_one();
+
+    // Test timed_wait.
+    boost::xtime xt = delay(10);
+    while (data->notified != 3)
+        data->condition.timed_wait(lock, xt);
+    BOOST_CHECK(lock ? true : false);
+    BOOST_CHECK_EQUAL(data->notified, 3);
+    data->awoken++;
+    data->condition.notify_one();
+
+    // Test predicate timed_wait.
+    xt = delay(10);
+    cond_predicate pred(data->notified, 4);
+    BOOST_CHECK(data->condition.timed_wait(lock, xt, pred));
+    BOOST_CHECK(lock ? true : false);
+    BOOST_CHECK(pred());
+    BOOST_CHECK_EQUAL(data->notified, 4);
+    data->awoken++;
+    data->condition.notify_one();
+
+    // Test predicate timed_wait with relative timeout
+    cond_predicate pred_rel(data->notified, 5);
+    BOOST_CHECK(data->condition.timed_wait(lock, boost::posix_time::seconds(10), pred_rel));
+    BOOST_CHECK(lock ? true : false);
+    BOOST_CHECK(pred_rel());
+    BOOST_CHECK_EQUAL(data->notified, 5);
+    data->awoken++;
+    data->condition.notify_one();
+}
+
+void do_test_condition_waits()
+{
+    condition_test_data data;
+
+    boost::thread thread(bind(&condition_test_waits, &data));
+
+    {
+        boost::mutex::scoped_lock lock(data.mutex);
+        BOOST_CHECK(lock ? true : false);
+
+        boost::thread::sleep(delay(1));
+        data.notified++;
+        data.condition.notify_one();
+        while (data.awoken != 1)
+            data.condition.wait(lock);
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data.awoken, 1);
+
+        boost::thread::sleep(delay(1));
+        data.notified++;
+        data.condition.notify_one();
+        while (data.awoken != 2)
+            data.condition.wait(lock);
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data.awoken, 2);
+
+        boost::thread::sleep(delay(1));
+        data.notified++;
+        data.condition.notify_one();
+        while (data.awoken != 3)
+            data.condition.wait(lock);
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data.awoken, 3);
+
+        boost::thread::sleep(delay(1));
+        data.notified++;
+        data.condition.notify_one();
+        while (data.awoken != 4)
+            data.condition.wait(lock);
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data.awoken, 4);
+
+
+        boost::thread::sleep(delay(1));
+        data.notified++;
+        data.condition.notify_one();
+        while (data.awoken != 5)
+            data.condition.wait(lock);
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data.awoken, 5);
+    }
+
+    thread.join();
+    BOOST_CHECK_EQUAL(data.awoken, 5);
+}
+
+void test_condition_waits()
+{
+    // We should have already tested notify_one here, so
+    // a timed test with the default execution_monitor::use_condition
+    // should be OK, and gives the fastest performance
+    timed_test(&do_test_condition_waits, 12);
+}
+
+void do_test_condition_wait_is_a_interruption_point()
+{
+    condition_test_data data;
+
+    boost::thread thread(bind(&condition_test_thread, &data));
+
+    thread.interrupt();
+    thread.join();
+    BOOST_CHECK_EQUAL(data.awoken,0);
+}
+
+
+void test_condition_wait_is_a_interruption_point()
+{
+    timed_test(&do_test_condition_wait_is_a_interruption_point, 1);
+}
+
+boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Threads: condition test suite");
+
+    test->add(BOOST_TEST_CASE(&test_condition_waits));
+    test->add(BOOST_TEST_CASE(&test_condition_wait_is_a_interruption_point));
+
+    return test;
+}

test/test_condition_notify_all.cpp

@@ -0,0 +1,222 @@
+// 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/thread.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#include <libs/thread/test/util.inl>
+#include "condition_test_common.hpp"
+
+unsigned const number_of_test_threads=5;
+
+void do_test_condition_notify_all_wakes_from_wait()
+{
+    wait_for_flag data;
+
+    boost::thread_group group;
+
+    try
+    {
+        for(unsigned i=0;i<number_of_test_threads;++i)
+        {
+            group.create_thread(bind(&wait_for_flag::wait_without_predicate, data));
+        }
+
+        {
+            boost::mutex::scoped_lock lock(data.mutex);
+            data.flag=true;
+            data.cond_var.notify_all();
+        }
+
+        group.join_all();
+        BOOST_CHECK_EQUAL(data.woken,number_of_test_threads);
+    }
+    catch(...)
+    {
+        group.join_all();
+        throw;
+    }
+}
+
+void do_test_condition_notify_all_wakes_from_wait_with_predicate()
+{
+    wait_for_flag data;
+
+    boost::thread_group group;
+
+    try
+    {
+        for(unsigned i=0;i<number_of_test_threads;++i)
+        {
+            group.create_thread(bind(&wait_for_flag::wait_with_predicate, data));
+        }
+
+        {
+            boost::mutex::scoped_lock lock(data.mutex);
+            data.flag=true;
+            data.cond_var.notify_all();
+        }
+
+        group.join_all();
+        BOOST_CHECK_EQUAL(data.woken,number_of_test_threads);
+    }
+    catch(...)
+    {
+        group.join_all();
+        throw;
+    }
+}
+
+void do_test_condition_notify_all_wakes_from_timed_wait()
+{
+    wait_for_flag data;
+
+    boost::thread_group group;
+
+    try
+    {
+        for(unsigned i=0;i<number_of_test_threads;++i)
+        {
+            group.create_thread(bind(&wait_for_flag::timed_wait_without_predicate, data));
+        }
+
+        {
+            boost::mutex::scoped_lock lock(data.mutex);
+            data.flag=true;
+            data.cond_var.notify_all();
+        }
+
+        group.join_all();
+        BOOST_CHECK_EQUAL(data.woken,number_of_test_threads);
+    }
+    catch(...)
+    {
+        group.join_all();
+        throw;
+    }
+}
+
+void do_test_condition_notify_all_wakes_from_timed_wait_with_predicate()
+{
+    wait_for_flag data;
+
+    boost::thread_group group;
+
+    try
+    {
+        for(unsigned i=0;i<number_of_test_threads;++i)
+        {
+            group.create_thread(bind(&wait_for_flag::timed_wait_with_predicate, data));
+        }
+
+        {
+            boost::mutex::scoped_lock lock(data.mutex);
+            data.flag=true;
+            data.cond_var.notify_all();
+        }
+
+        group.join_all();
+        BOOST_CHECK_EQUAL(data.woken,number_of_test_threads);
+    }
+    catch(...)
+    {
+        group.join_all();
+        throw;
+    }
+}
+
+void do_test_condition_notify_all_wakes_from_relative_timed_wait_with_predicate()
+{
+    wait_for_flag data;
+
+    boost::thread_group group;
+
+    try
+    {
+        for(unsigned i=0;i<number_of_test_threads;++i)
+        {
+            group.create_thread(bind(&wait_for_flag::relative_timed_wait_with_predicate, data));
+        }
+
+        {
+            boost::mutex::scoped_lock lock(data.mutex);
+            data.flag=true;
+            data.cond_var.notify_all();
+        }
+
+        group.join_all();
+        BOOST_CHECK_EQUAL(data.woken,number_of_test_threads);
+    }
+    catch(...)
+    {
+        group.join_all();
+        throw;
+    }
+}
+
+namespace
+{
+    boost::mutex multiple_wake_mutex;
+    boost::condition_variable multiple_wake_cond;
+    unsigned multiple_wake_count=0;
+
+    void wait_for_condvar_and_increase_count()
+    {
+        boost::mutex::scoped_lock lk(multiple_wake_mutex);
+        multiple_wake_cond.wait(lk);
+        ++multiple_wake_count;
+    }
+    
+}
+
+
+void do_test_notify_all_following_notify_one_wakes_all_threads()
+{
+    boost::thread thread1(wait_for_condvar_and_increase_count);
+    boost::thread thread2(wait_for_condvar_and_increase_count);
+
+    boost::this_thread::sleep(boost::posix_time::milliseconds(200));
+    multiple_wake_cond.notify_one();
+
+    boost::thread thread3(wait_for_condvar_and_increase_count);
+
+    boost::this_thread::sleep(boost::posix_time::milliseconds(200));
+    multiple_wake_cond.notify_one();
+    multiple_wake_cond.notify_all();
+    boost::this_thread::sleep(boost::posix_time::milliseconds(200));
+    
+    {
+        boost::mutex::scoped_lock lk(multiple_wake_mutex);
+        BOOST_CHECK(multiple_wake_count==3);
+    }
+
+    thread1.join();
+    thread2.join();
+    thread3.join();
+}
+
+void test_condition_notify_all()
+{
+    timed_test(&do_test_condition_notify_all_wakes_from_wait, timeout_seconds);
+    timed_test(&do_test_condition_notify_all_wakes_from_wait_with_predicate, timeout_seconds);
+    timed_test(&do_test_condition_notify_all_wakes_from_timed_wait, timeout_seconds);
+    timed_test(&do_test_condition_notify_all_wakes_from_timed_wait_with_predicate, timeout_seconds);
+    timed_test(&do_test_condition_notify_all_wakes_from_relative_timed_wait_with_predicate, timeout_seconds);
+    timed_test(&do_test_notify_all_following_notify_one_wakes_all_threads, timeout_seconds);
+}
+
+
+boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Threads: condition test suite");
+
+    test->add(BOOST_TEST_CASE(&test_condition_notify_all));
+
+    return test;
+}

test/test_condition_notify_one.cpp

@@ -0,0 +1,155 @@
+// 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/thread.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#include <libs/thread/test/util.inl>
+#include "condition_test_common.hpp"
+
+void do_test_condition_notify_one_wakes_from_wait()
+{
+    wait_for_flag data;
+    
+    boost::thread thread(bind(&wait_for_flag::wait_without_predicate, data));
+
+    {
+        boost::mutex::scoped_lock lock(data.mutex);
+        data.flag=true;
+        data.cond_var.notify_one();
+    }
+
+    thread.join();
+    BOOST_CHECK(data.woken);
+}
+
+void do_test_condition_notify_one_wakes_from_wait_with_predicate()
+{
+    wait_for_flag data;
+    
+    boost::thread thread(bind(&wait_for_flag::wait_with_predicate, data));
+
+    {
+        boost::mutex::scoped_lock lock(data.mutex);
+        data.flag=true;
+        data.cond_var.notify_one();
+    }
+
+    thread.join();
+    BOOST_CHECK(data.woken);
+}
+
+void do_test_condition_notify_one_wakes_from_timed_wait()
+{
+    wait_for_flag data;
+    
+    boost::thread thread(bind(&wait_for_flag::timed_wait_without_predicate, data));
+
+    {
+        boost::mutex::scoped_lock lock(data.mutex);
+        data.flag=true;
+        data.cond_var.notify_one();
+    }
+
+    thread.join();
+    BOOST_CHECK(data.woken);
+}
+
+void do_test_condition_notify_one_wakes_from_timed_wait_with_predicate()
+{
+    wait_for_flag data;
+    
+    boost::thread thread(bind(&wait_for_flag::timed_wait_with_predicate, data));
+
+    {
+        boost::mutex::scoped_lock lock(data.mutex);
+        data.flag=true;
+        data.cond_var.notify_one();
+    }
+
+    thread.join();
+    BOOST_CHECK(data.woken);
+}
+
+void do_test_condition_notify_one_wakes_from_relative_timed_wait_with_predicate()
+{
+    wait_for_flag data;
+    
+    boost::thread thread(bind(&wait_for_flag::relative_timed_wait_with_predicate, data));
+
+    {
+        boost::mutex::scoped_lock lock(data.mutex);
+        data.flag=true;
+        data.cond_var.notify_one();
+    }
+
+    thread.join();
+    BOOST_CHECK(data.woken);
+}
+
+namespace
+{
+    boost::mutex multiple_wake_mutex;
+    boost::condition_variable multiple_wake_cond;
+    unsigned multiple_wake_count=0;
+
+    void wait_for_condvar_and_increase_count()
+    {
+        boost::mutex::scoped_lock lk(multiple_wake_mutex);
+        multiple_wake_cond.wait(lk);
+        ++multiple_wake_count;
+    }
+    
+}
+
+
+void do_test_multiple_notify_one_calls_wakes_multiple_threads()
+{
+    boost::thread thread1(wait_for_condvar_and_increase_count);
+    boost::thread thread2(wait_for_condvar_and_increase_count);
+
+    boost::this_thread::sleep(boost::posix_time::milliseconds(200));
+    multiple_wake_cond.notify_one();
+
+    boost::thread thread3(wait_for_condvar_and_increase_count);
+
+    boost::this_thread::sleep(boost::posix_time::milliseconds(200));
+    multiple_wake_cond.notify_one();
+    multiple_wake_cond.notify_one();
+    boost::this_thread::sleep(boost::posix_time::milliseconds(200));
+    
+    {
+        boost::mutex::scoped_lock lk(multiple_wake_mutex);
+        BOOST_CHECK(multiple_wake_count==3);
+    }
+
+    thread1.join();
+    thread2.join();
+    thread3.join();
+}
+
+void test_condition_notify_one()
+{
+    timed_test(&do_test_condition_notify_one_wakes_from_wait, timeout_seconds, execution_monitor::use_mutex);
+    timed_test(&do_test_condition_notify_one_wakes_from_wait_with_predicate, timeout_seconds, execution_monitor::use_mutex);
+    timed_test(&do_test_condition_notify_one_wakes_from_timed_wait, timeout_seconds, execution_monitor::use_mutex);
+    timed_test(&do_test_condition_notify_one_wakes_from_timed_wait_with_predicate, timeout_seconds, execution_monitor::use_mutex);
+    timed_test(&do_test_condition_notify_one_wakes_from_relative_timed_wait_with_predicate, timeout_seconds, execution_monitor::use_mutex);
+    timed_test(&do_test_multiple_notify_one_calls_wakes_multiple_threads, timeout_seconds, execution_monitor::use_mutex);
+}
+
+
+boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Threads: condition test suite");
+
+    test->add(BOOST_TEST_CASE(&test_condition_notify_one));
+
+    return test;
+}

test/test_condition_timed_wait_times_out.cpp

@@ -0,0 +1,173 @@
+// Copyright (C) 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
+
+#include <boost/test/unit_test.hpp>
+#include "util.inl"
+
+bool fake_predicate()
+{
+    return false;
+}
+
+unsigned const timeout_seconds=2;
+unsigned const timeout_grace=1;
+boost::posix_time::milliseconds const timeout_resolution(100);
+
+
+void do_test_timed_wait_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();
+    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_timed_wait_with_predicate_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();
+    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_relative_timed_wait_with_predicate_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();
+
+    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_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*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Threads: condition test suite");
+
+    test->add(BOOST_TEST_CASE(&test_timed_wait_times_out));
+
+    return test;
+}