Branch for development of boost.system related changes

[SVN r40931]

build/Jamfile.v2

@@ -1,39 +1,207 @@
-# (C) Copyright Vladimir Prus, David Abrahams, Michael Stevens, Hartmut Kaiser, 
-# William E Kempf 2002-2006
-# 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)
+# $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 <link>shared:<define>BOOST_THREAD_BUILD_DLL=1  <threading>multi 
+    : 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
     : default-build <threading>multi
     ;
 
-CPP_SOURCES =  
-        barrier
-        condition
-        exceptions
-        mutex
-        once
-        recursive_mutex
-#        read_write_mutex
-        thread
-        tss_hooks
-        tss_dll
-        tss_pe
-        tss
-        xtime
+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/exceptions.cpp
+      win32/tss.cpp
+      win32/tss_hooks.cpp
+      win32/tss_dll.cpp
+      win32/tss_pe.cpp
+    : ## requirements ##
+      <threadapi>win32
     ;
 
+alias thread_sources
+    : ## pthread sources ##
+      pthread/thread.cpp
+      pthread/exceptions.cpp
+      pthread/tss.cpp
+    : ## requirements ##
+      <threadapi>pthread
+    ;
+
+explicit thread_sources ;
+
 lib boost_thread
-   : $(CPP_SOURCES).cpp
-   : <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
-     <link>static:<define>BOOST_THREAD_BUILD_LIB=1
-   : # default build
-   : <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
-     <link>static:<define>BOOST_THREAD_BUILD_LIB=1
-   ;
+    : thread_sources
+    : <conditional>@requirements
+    :
+    : <conditional>@usage-requirements
+    ;

doc/once-ref.xml

@@ -65,25 +65,23 @@ void init()
 
 void thread_proc()
 {
-    boost::call_once(&init, once);
+    boost::call_once(once, &init);
 }</programlisting>
 			</para></description>
 			
-			<parameter name="func">
-				<paramtype>void (*func)()</paramtype>
-			</parameter>
-			
 			<parameter name="flag">
 				<paramtype>once_flag&amp;</paramtype>
 			</parameter>
-			
-			<requires>The function <code>func</code> shall not throw
-			exceptions.</requires>
+
+			<parameter name="func">
+				<paramtype>Function func</paramtype>
+			</parameter>
 			
 			<effects>As if (in an atomic fashion): 
-			<code>if (flag == BOOST_ONCE_INIT) func();</code></effects>
+			<code>if (flag == BOOST_ONCE_INIT) func();</code>. If <code>func()</code> throws an exception, it shall be as if this
+thread never invoked <code>call_once</code></effects>
 			
-			<postconditions><code>flag != BOOST_ONCE_INIT</code>
+			<postconditions><code>flag != BOOST_ONCE_INIT</code> unless <code>func()</code> throws an exception.
 			</postconditions>
 		</function>
 	</namespace>

doc/read_write_mutex-ref.xml

@@ -37,6 +37,16 @@
 		<purpose>
 			<para>The <classname>read_write_mutex</classname> class is a model of the 
 			<link linkend="thread.concepts.ReadWriteMutex">ReadWriteMutex</link> concept.</para>
+    <note> Unfortunately it turned out that the current implementation of Read/Write Mutex has     
+            some serious problems. So it was decided not to put this implementation into
+            release grade code. Also discussions on the mailing list led to the
+            conclusion that the current concepts need to be rethought. In particular
+            the schedulings <link linkend="thread.concepts.read-write-scheduling-policies.inter-class">
+                Inter-Class Scheduling Policies</link> are deemed unnecessary.
+            There seems to be common belief that a fair scheme suffices.
+            The following documentation has been retained however, to give
+            readers of this document the opportunity to study the original design.
+    </note>
 		</purpose>
 		
 		<description>
@@ -160,6 +170,16 @@
 		<purpose>
 			<para>The <classname>try_read_write_mutex</classname> class is a model of the 
 			<link linkend="thread.concepts.TryReadWriteMutex">TryReadWriteMutex</link> concept.</para>
+    <note> Unfortunately it turned out that the current implementation of Read/Write Mutex has     
+            some serious problems. So it was decided not to put this implementation into
+            release grade code. Also discussions on the mailing list led to the
+            conclusion that the current concepts need to be rethought. In particular
+            the schedulings <link linkend="thread.concepts.read-write-scheduling-policies.inter-class">
+                Inter-Class Scheduling Policies</link> are deemed unnecessary.
+            There seems to be common belief that a fair scheme suffices.
+            The following documentation has been retained however, to give
+            readers of this document the opportunity to study the original design.
+    </note>
 		</purpose>
 		
 		<description>
@@ -302,6 +322,16 @@
 		<purpose>
 			<para>The <classname>timed_read_write_mutex</classname> class is a model of the 
 			<link linkend="thread.concepts.TimedReadWriteMutex">TimedReadWriteMutex</link> concept.</para>
+    <note> Unfortunately it turned out that the current implementation of Read/Write Mutex has     
+            some serious problems. So it was decided not to put this implementation into
+            release grade code. Also discussions on the mailing list led to the
+            conclusion that the current concepts need to be rethought. In particular
+            the schedulings <link linkend="thread.concepts.read-write-scheduling-policies.inter-class">
+                Inter-Class Scheduling Policies</link> are deemed unnecessary.
+            There seems to be common belief that a fair scheme suffices.
+            The following documentation has been retained however, to give
+            readers of this document the opportunity to study the original design.
+    </note>
 		</purpose>
 		
 		<description>

include/boost/thread/barrier.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2002-2003
 // David Moore, 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)
@@ -10,34 +11,48 @@
 #include <boost/thread/detail/config.hpp>
 
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/condition.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <string>
+#include <stdexcept>
 
-namespace boost {
-
-class BOOST_THREAD_DECL barrier
+namespace boost
 {
-public:
-    barrier(unsigned int count);
-    ~barrier();
 
-    bool wait();
+    class barrier
+    {
+    public:
+        barrier(unsigned int count)
+            : m_threshold(count), m_count(count), m_generation(0)
+        {
+            if (count == 0)
+                throw 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;
+            }
 
-private:
-    mutex m_mutex;
-// disable warnings about non dll import
-// see: http://www.boost.org/more/separate_compilation.html#dlls
-#ifdef BOOST_MSVC
-#   pragma warning(push)
-#   pragma warning(disable: 4251 4231 4660 4275)
-#endif
-    condition m_cond;
-#ifdef BOOST_MSVC
-#   pragma warning(pop)
-#endif
-    unsigned int m_threshold;
-    unsigned int m_count;
-    unsigned int m_generation;
-};
+            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/thread/condition.hpp

@@ -1,201 +1,16 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+#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)
+//  Distributed under the 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_CONDITION_WEK070601_HPP
-#define BOOST_CONDITION_WEK070601_HPP
+#include <boost/thread/condition_variable.hpp>
 
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/thread/exceptions.hpp>
-#include <boost/utility.hpp>
-#include <boost/thread/detail/lock.hpp>
-
-#if defined(BOOST_HAS_PTHREADS)
-#   include <pthread.h>
-#elif defined(BOOST_HAS_MPTASKS)
-#   include "scoped_critical_region.hpp"
-#endif
-
-namespace boost {
-
-struct xtime;
-// disable warnings about non dll import
-// see: http://www.boost.org/more/separate_compilation.html#dlls
-#ifdef BOOST_MSVC
-#   pragma warning(push)
-#   pragma warning(disable: 4251 4231 4660 4275)
-#endif
-
-namespace detail {
-
-class BOOST_THREAD_DECL condition_impl : private noncopyable
+namespace boost
 {
-    friend class condition;
+    typedef condition_variable_any condition;
+}
 
-public:
-    condition_impl();
-    ~condition_impl();
-
-    void notify_one();
-    void notify_all();
-
-#if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-    void enter_wait();
-    void do_wait();
-    bool do_timed_wait(const xtime& xt);
-#elif defined(BOOST_HAS_PTHREADS)
-    void do_wait(pthread_mutex_t* pmutex);
-    bool do_timed_wait(const xtime& xt, pthread_mutex_t* pmutex);
 #endif
-
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_gate;
-    void* m_queue;
-    void* m_mutex;
-    unsigned m_gone;  // # threads that timed out and never made it to m_queue
-    unsigned long m_blocked; // # threads blocked on the condition
-    unsigned m_waiting; // # threads no longer waiting for the condition but
-                        // still waiting to be removed from m_queue
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_cond_t m_condition;
-#elif defined(BOOST_HAS_MPTASKS)
-    MPSemaphoreID m_gate;
-    MPSemaphoreID m_queue;
-    threads::mac::detail::scoped_critical_region m_mutex;
-    threads::mac::detail::scoped_critical_region m_mutex_mutex;
-    unsigned m_gone; // # threads that timed out and never made it to m_queue
-    unsigned long m_blocked; // # threads blocked on the condition
-    unsigned m_waiting; // # threads no longer waiting for the condition but
-                        // still waiting to be removed from m_queue
-#endif
-};
-
-} // namespace detail
-
-class condition : private noncopyable
-{
-public:
-    condition() { }
-    ~condition() { }
-
-    void notify_one() { m_impl.notify_one(); }
-    void notify_all() { m_impl.notify_all(); }
-
-    template <typename L>
-    void wait(L& lock)
-    {
-        if (!lock)
-            throw lock_error();
-
-        do_wait(lock.m_mutex);
-    }
-
-    template <typename L, typename Pr>
-    void wait(L& lock, Pr pred)
-    {
-        if (!lock)
-            throw lock_error();
-
-        while (!pred())
-            do_wait(lock.m_mutex);
-    }
-
-    template <typename L>
-    bool timed_wait(L& lock, const xtime& xt)
-    {
-        if (!lock)
-            throw lock_error();
-
-        return do_timed_wait(lock.m_mutex, xt);
-    }
-
-    template <typename L, typename Pr>
-    bool timed_wait(L& lock, const xtime& xt, Pr pred)
-    {
-        if (!lock)
-            throw lock_error();
-
-        while (!pred())
-        {
-            if (!do_timed_wait(lock.m_mutex, xt))
-                return false;
-        }
-
-        return true;
-    }
-
-private:
-    detail::condition_impl m_impl;
-
-    template <typename M>
-    void do_wait(M& mutex)
-    {
-#if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-        m_impl.enter_wait();
-#endif
-
-        typedef detail::thread::lock_ops<M>
-#if defined(__HP_aCC) && __HP_aCC <= 33900 && !defined(BOOST_STRICT_CONFIG)
-# define lock_ops lock_ops_  // HP confuses lock_ops witht the template
-#endif
-            lock_ops;
-
-        typename lock_ops::lock_state state;
-        lock_ops::unlock(mutex, state);
-
-#if defined(BOOST_HAS_PTHREADS)
-        m_impl.do_wait(state.pmutex);
-#elif (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-        m_impl.do_wait();
-#endif
-
-        lock_ops::lock(mutex, state);
-#undef lock_ops
-    }
-
-    template <typename M>
-    bool do_timed_wait(M& mutex, const xtime& xt)
-    {
-#if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-        m_impl.enter_wait();
-#endif
-
-        typedef detail::thread::lock_ops<M>
-#if defined(__HP_aCC) && __HP_aCC <= 33900 && !defined(BOOST_STRICT_CONFIG)
-# define lock_ops lock_ops_  // HP confuses lock_ops witht the template
-#endif
-            lock_ops;
-
-        typename lock_ops::lock_state state;
-        lock_ops::unlock(mutex, state);
-
-        bool ret = false;
-
-#if defined(BOOST_HAS_PTHREADS)
-        ret = m_impl.do_timed_wait(xt, state.pmutex);
-#elif (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-        ret = m_impl.do_timed_wait(xt);
-#endif
-
-        lock_ops::lock(mutex, state);
-#undef lock_ops
-
-        return ret;
-    }
-};
-#ifdef BOOST_MSVC
-#   pragma warning(pop)
-#endif
-} // namespace boost
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//   22 May 01  WEKEMPF Modified to use xtime for time outs.
-//   23 May 01  WEKEMPF Removed "duration" timed_waits, as they are too
-//                      difficult to use with spurious wakeups.
-//    3 Jan 03  WEKEMPF Modified for DLL implementation.
-
-#endif // BOOST_CONDITION_WEK070601_HPP

include/boost/thread/condition_variable.hpp

@@ -0,0 +1,15 @@
+#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>
+#include BOOST_THREAD_PLATFORM(condition_variable.hpp)
+
+#endif

include/boost/thread/detail/lock.hpp

@@ -1,209 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_XLOCK_WEK070601_HPP
-#define BOOST_XLOCK_WEK070601_HPP
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/thread/exceptions.hpp>
-
-namespace boost {
-
-class condition;
-struct xtime;
-
-namespace detail { namespace thread {
-
-template <typename Mutex>
-class lock_ops : private noncopyable
-{
-private:
-    lock_ops() { }
-
-public:
-    typedef typename Mutex::cv_state lock_state;
-
-    static void lock(Mutex& m)
-    {
-        m.do_lock();
-    }
-    static bool trylock(Mutex& m)
-    {
-        return m.do_trylock();
-    }
-    static bool timedlock(Mutex& m, const xtime& xt)
-    {
-        return m.do_timedlock(xt);
-    }
-    static void unlock(Mutex& m)
-    {
-        m.do_unlock();
-    }
-    static void lock(Mutex& m, lock_state& state)
-    {
-        m.do_lock(state);
-    }
-    static void unlock(Mutex& m, lock_state& state)
-    {
-        m.do_unlock(state);
-    }
-};
-
-template <typename Mutex>
-class scoped_lock : private noncopyable
-{
-public:
-    typedef Mutex mutex_type;
-
-    explicit scoped_lock(Mutex& mx, bool initially_locked=true)
-        : m_mutex(mx), m_locked(false)
-    {
-        if (initially_locked) lock();
-    }
-    ~scoped_lock()
-    {
-        if (m_locked) unlock();
-    }
-
-    void lock()
-    {
-        if (m_locked) throw lock_error();
-        lock_ops<Mutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<Mutex>::unlock(m_mutex);
-        m_locked = false;
-    }
-
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
-
-private:
-    friend class boost::condition;
-
-    Mutex& m_mutex;
-    bool m_locked;
-};
-
-template <typename TryMutex>
-class scoped_try_lock : private noncopyable
-{
-public:
-    typedef TryMutex mutex_type;
-
-    explicit scoped_try_lock(TryMutex& mx)
-        : m_mutex(mx), m_locked(false)
-    {
-        try_lock();
-    }
-    scoped_try_lock(TryMutex& mx, bool initially_locked)
-        : m_mutex(mx), m_locked(false)
-    {
-        if (initially_locked) lock();
-    }
-    ~scoped_try_lock()
-    {
-        if (m_locked) unlock();
-    }
-
-    void lock()
-    {
-        if (m_locked) throw lock_error();
-        lock_ops<TryMutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    bool try_lock()
-    {
-        if (m_locked) throw lock_error();
-        return (m_locked = lock_ops<TryMutex>::trylock(m_mutex));
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<TryMutex>::unlock(m_mutex);
-        m_locked = false;
-    }
-
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
-
-private:
-    friend class boost::condition;
-
-    TryMutex& m_mutex;
-    bool m_locked;
-};
-
-template <typename TimedMutex>
-class scoped_timed_lock : private noncopyable
-{
-public:
-    typedef TimedMutex mutex_type;
-
-    scoped_timed_lock(TimedMutex& mx, const xtime& xt)
-        : m_mutex(mx), m_locked(false)
-    {
-        timed_lock(xt);
-    }
-    scoped_timed_lock(TimedMutex& mx, bool initially_locked)
-        : m_mutex(mx), m_locked(false)
-    {
-        if (initially_locked) lock();
-    }
-    ~scoped_timed_lock()
-    {
-        if (m_locked) unlock();
-    }
-
-    void lock()
-    {
-        if (m_locked) throw lock_error();
-        lock_ops<TimedMutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    bool try_lock()
-    {
-        if (m_locked) throw lock_error();
-        return (m_locked = lock_ops<TimedMutex>::trylock(m_mutex));
-    }
-    bool timed_lock(const xtime& xt)
-    {
-        if (m_locked) throw lock_error();
-        return (m_locked = lock_ops<TimedMutex>::timedlock(m_mutex, xt));
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<TimedMutex>::unlock(m_mutex);
-        m_locked = false;
-    }
-
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
-
-private:
-    friend class boost::condition;
-
-    TimedMutex& m_mutex;
-    bool m_locked;
-};
-
-} // namespace thread
-} // namespace detail
-} // namespace boost
-
-#endif // BOOST_XLOCK_WEK070601_HPP
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//   22 May 01  WEKEMPF Modified to use xtime for time outs.
-//   30 Jul 01  WEKEMPF Moved lock types into boost::detail::thread. Renamed
-//                      some types. Added locked() methods.

include/boost/thread/detail/move.hpp

@@ -0,0 +1,33 @@
+// Distributed under the 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 BOOST_THREAD_MOVE_HPP
+#define BOOST_THREAD_MOVE_HPP
+
+namespace boost
+{
+    template<typename T>
+    struct move_t
+    {
+        T& t;
+        move_t(T& t_):
+            t(t_)
+        {}
+
+        T* operator->() const
+        {
+            return &t;
+        }
+    };
+
+    template<typename T>
+    move_t<T> move(T& t)
+    {
+        return move_t<T>(t);
+    }
+}
+
+
+#endif

include/boost/thread/detail/platform.hpp

@@ -0,0 +1,72 @@
+// Copyright 2006 Roland Schwarz.
+// Distributed under the 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)
+#  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_PPFX pthread
+#else
+#  if defined(BOOST_THREAD_WIN32)
+#       define BOOST_THREAD_PPFX win32
+#  elif defined(BOOST_HAS_PTHREADS)
+#       define BOOST_THREAD_PPFX pthread
+#  else
+#       error "Sorry, no boost threads are available for this platform."
+#  endif
+#endif
+
+#define BOOST_THREAD_PLATFORM(header) <boost/thread/BOOST_THREAD_PPFX/header>
+
+#endif // BOOST_THREAD_RS06040501_HPP

include/boost/thread/exceptions.hpp

@@ -1,5 +1,6 @@
 // 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)
@@ -35,6 +36,17 @@ private:
     int m_sys_err;
 };
 
+    class condition_error:
+        public std::exception
+    {
+    public:
+        const char* what() const throw()
+        {
+            return "Condition error";
+        }
+    };
+    
+
 class BOOST_THREAD_DECL lock_error : public thread_exception
 {
 public:

include/boost/thread/locks.hpp

@@ -0,0 +1,520 @@
+// Distributed under the 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 BOOST_THREAD_LOCKS_HPP
+#define BOOST_THREAD_LOCKS_HPP
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <algorithm>
+#include <boost/thread/thread_time.hpp>
+
+namespace boost
+{
+    struct defer_lock_t
+    {};
+    struct try_to_lock_t
+    {};
+    struct adopt_lock_t
+    {};
+    
+    const defer_lock_t defer_lock={};
+    const try_to_lock_t try_to_lock={};
+    const adopt_lock_t adopt_lock={};
+
+    template<typename Mutex>
+    class shared_lock;
+
+    template<typename Mutex>
+    class exclusive_lock;
+
+    template<typename Mutex>
+    class upgrade_lock;
+
+    template<typename Mutex>
+    class lock_guard
+    {
+    private:
+        Mutex& m;
+
+        explicit lock_guard(lock_guard&);
+        lock_guard& operator=(lock_guard&);
+    public:
+        explicit lock_guard(Mutex& m_):
+            m(m_)
+        {
+            m.lock();
+        }
+        lock_guard(Mutex& m_,adopt_lock_t):
+            m(m_)
+        {}
+        ~lock_guard()
+        {
+            m.unlock();
+        }
+    };
+
+
+    template<typename Mutex>
+    class unique_lock
+    {
+    private:
+        Mutex* m;
+        bool is_locked;
+        explicit unique_lock(unique_lock&);
+        unique_lock& operator=(unique_lock&);
+    public:
+        explicit unique_lock(Mutex& m_):
+            m(&m_),is_locked(false)
+        {
+            lock();
+        }
+        unique_lock(Mutex& m_,adopt_lock_t):
+            m(&m_),is_locked(true)
+        {}
+        unique_lock(Mutex& m_,defer_lock_t):
+            m(&m_),is_locked(false)
+        {}
+        unique_lock(Mutex& m_,try_to_lock_t):
+            m(&m_),is_locked(false)
+        {
+            try_lock();
+        }
+        unique_lock(Mutex& m_,system_time const& target_time):
+            m(&m_),is_locked(false)
+        {
+            timed_lock(target_time);
+        }
+        unique_lock(boost::move_t<unique_lock<Mutex> > other):
+            m(other->m),is_locked(other->is_locked)
+        {
+            other->is_locked=false;
+        }
+        unique_lock(boost::move_t<upgrade_lock<Mutex> > other);
+
+        unique_lock& operator=(boost::move_t<unique_lock<Mutex> > other)
+        {
+            unique_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+
+        unique_lock& operator=(boost::move_t<upgrade_lock<Mutex> > other)
+        {
+            unique_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+
+        void swap(unique_lock& other)
+        {
+            std::swap(m,other.m);
+            std::swap(is_locked,other.is_locked);
+        }
+        void swap(boost::move_t<unique_lock<Mutex> > other)
+        {
+            std::swap(m,other->m);
+            std::swap(is_locked,other->is_locked);
+        }
+        
+        ~unique_lock()
+        {
+            if(owns_lock())
+            {
+                m->unlock();
+            }
+        }
+        void lock()
+        {
+            if(owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            m->lock();
+            is_locked=true;
+        }
+        bool try_lock()
+        {
+            if(owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            is_locked=m->try_lock();
+            return is_locked;
+        }
+        template<typename TimeDuration>
+        bool timed_lock(TimeDuration const& relative_time)
+        {
+            is_locked=m->timed_lock(relative_time);
+            return is_locked;
+        }
+        
+        bool timed_lock(::boost::system_time const& absolute_time)
+        {
+            is_locked=m->timed_lock(absolute_time);
+            return is_locked;
+        }
+        void unlock()
+        {
+            if(!owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            m->unlock();
+            is_locked=false;
+        }
+            
+        typedef void (unique_lock::*bool_type)();
+        operator bool_type() const
+        {
+            return is_locked?&unique_lock::lock:0;
+        }
+        bool operator!() const
+        {
+            return !owns_lock();
+        }
+        bool owns_lock() const
+        {
+            return is_locked;
+        }
+
+        Mutex* mutex() const
+        {
+            return m;
+        }
+
+        Mutex* release()
+        {
+            Mutex* const res=m;
+            m=0;
+            is_locked=false;
+            return res;
+        }
+
+        friend class shared_lock<Mutex>;
+        friend class upgrade_lock<Mutex>;
+    };
+
+    template<typename Mutex>
+    class shared_lock
+    {
+    protected:
+        Mutex* m;
+        bool is_locked;
+    private:
+        explicit shared_lock(shared_lock&);
+        shared_lock& operator=(shared_lock&);
+    public:
+        explicit shared_lock(Mutex& m_):
+            m(&m_),is_locked(false)
+        {
+            lock();
+        }
+        shared_lock(Mutex& m_,adopt_lock_t):
+            m(&m_),is_locked(true)
+        {}
+        shared_lock(Mutex& m_,defer_lock_t):
+            m(&m_),is_locked(false)
+        {}
+        shared_lock(Mutex& m_,try_to_lock_t):
+            m(&m_),is_locked(false)
+        {
+            try_lock();
+        }
+        shared_lock(Mutex& m_,system_time const& target_time):
+            m(&m_),is_locked(false)
+        {
+            timed_lock(target_time);
+        }
+
+        shared_lock(boost::move_t<shared_lock<Mutex> > other):
+            m(other->m),is_locked(other->is_locked)
+        {
+            other->is_locked=false;
+        }
+
+        shared_lock(boost::move_t<unique_lock<Mutex> > other):
+            m(other->m),is_locked(other->is_locked)
+        {
+            other->is_locked=false;
+            if(is_locked)
+            {
+                m->unlock_and_lock_shared();
+            }
+        }
+
+        shared_lock(boost::move_t<upgrade_lock<Mutex> > other):
+            m(other->m),is_locked(other->is_locked)
+        {
+            other->is_locked=false;
+            if(is_locked)
+            {
+                m->unlock_upgrade_and_lock_shared();
+            }
+        }
+
+        shared_lock& operator=(boost::move_t<shared_lock<Mutex> > other)
+        {
+            shared_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+
+        shared_lock& operator=(boost::move_t<unique_lock<Mutex> > other)
+        {
+            shared_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+
+        shared_lock& operator=(boost::move_t<upgrade_lock<Mutex> > other)
+        {
+            shared_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+
+        void swap(shared_lock& other)
+        {
+            std::swap(m,other.m);
+            std::swap(is_locked,other.is_locked);
+        }
+        
+        ~shared_lock()
+        {
+            if(owns_lock())
+            {
+                m->unlock_shared();
+            }
+        }
+        void lock()
+        {
+            if(owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            m->lock_shared();
+            is_locked=true;
+        }
+        bool try_lock()
+        {
+            if(owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            is_locked=m->try_lock_shared();
+            return is_locked;
+        }
+        bool timed_lock(boost::system_time const& target_time)
+        {
+            if(owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            is_locked=m->timed_lock_shared(target_time);
+            return is_locked;
+        }
+        void unlock()
+        {
+            if(!owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            m->unlock_shared();
+            is_locked=false;
+        }
+            
+        typedef void (shared_lock::*bool_type)();
+        operator bool_type() const
+        {
+            return is_locked?&shared_lock::lock:0;
+        }
+        bool operator!() const
+        {
+            return !owns_lock();
+        }
+        bool owns_lock() const
+        {
+            return is_locked;
+        }
+
+    };
+
+    template<typename Mutex>
+    class upgrade_lock
+    {
+    protected:
+        Mutex* m;
+        bool is_locked;
+    private:
+        explicit upgrade_lock(upgrade_lock&);
+        upgrade_lock& operator=(upgrade_lock&);
+    public:
+        explicit upgrade_lock(Mutex& m_):
+            m(&m_),is_locked(false)
+        {
+            lock();
+        }
+        upgrade_lock(Mutex& m_,bool do_lock):
+            m(&m_),is_locked(false)
+        {
+            if(do_lock)
+            {
+                lock();
+            }
+        }
+        upgrade_lock(boost::move_t<upgrade_lock<Mutex> > other):
+            m(other->m),is_locked(other->is_locked)
+        {
+            other->is_locked=false;
+        }
+
+        upgrade_lock(boost::move_t<unique_lock<Mutex> > other):
+            m(other->m),is_locked(other->is_locked)
+        {
+            other->is_locked=false;
+            if(is_locked)
+            {
+                m->unlock_and_lock_upgrade();
+            }
+        }
+
+        upgrade_lock& operator=(boost::move_t<upgrade_lock<Mutex> > other)
+        {
+            upgrade_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+
+        upgrade_lock& operator=(boost::move_t<unique_lock<Mutex> > other)
+        {
+            upgrade_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+
+        void swap(upgrade_lock& other)
+        {
+            std::swap(m,other.m);
+            std::swap(is_locked,other.is_locked);
+        }
+        
+        ~upgrade_lock()
+        {
+            if(owns_lock())
+            {
+                m->unlock_upgrade();
+            }
+        }
+        void lock()
+        {
+            if(owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            m->lock_upgrade();
+            is_locked=true;
+        }
+        bool try_lock()
+        {
+            if(owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            is_locked=m->try_lock_upgrade();
+            return is_locked;
+        }
+        void unlock()
+        {
+            if(!owns_lock())
+            {
+                throw boost::lock_error();
+            }
+            m->unlock_upgrade();
+            is_locked=false;
+        }
+            
+        typedef void (upgrade_lock::*bool_type)();
+        operator bool_type() const
+        {
+            return is_locked?&upgrade_lock::lock:0;
+        }
+        bool operator!() const
+        {
+            return !owns_lock();
+        }
+        bool owns_lock() const
+        {
+            return is_locked;
+        }
+        friend class shared_lock<Mutex>;
+        friend class unique_lock<Mutex>;
+    };
+
+    template<typename Mutex>
+    unique_lock<Mutex>::unique_lock(boost::move_t<upgrade_lock<Mutex> > other):
+        m(other->m),is_locked(other->is_locked)
+    {
+        other->is_locked=false;
+        if(is_locked)
+        {
+            m->unlock_upgrade_and_lock();
+        }
+    }
+
+    template <class Mutex>
+    class upgrade_to_unique_lock
+    {
+    private:
+        upgrade_lock<Mutex>* source;
+        unique_lock<Mutex> exclusive;
+
+        explicit upgrade_to_unique_lock(upgrade_to_unique_lock&);
+        upgrade_to_unique_lock& operator=(upgrade_to_unique_lock&);
+    public:
+        explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_):
+            source(&m_),exclusive(boost::move(*source))
+        {}
+        ~upgrade_to_unique_lock()
+        {
+            if(source)
+            {
+                *source=boost::move(exclusive);
+            }
+        }
+
+        upgrade_to_unique_lock(boost::move_t<upgrade_to_unique_lock<Mutex> > other):
+            source(other->source),exclusive(boost::move(other->exclusive))
+        {
+            other->source=0;
+        }
+        
+        upgrade_to_unique_lock& operator=(boost::move_t<upgrade_to_unique_lock<Mutex> > other)
+        {
+            upgrade_to_unique_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+        void swap(upgrade_to_unique_lock& other)
+        {
+            std::swap(source,other.source);
+            exclusive.swap(other.exclusive);
+        }
+        typedef void (upgrade_to_unique_lock::*bool_type)(upgrade_to_unique_lock&);
+        operator bool_type() const
+        {
+            return exclusive.owns_lock()?&upgrade_to_unique_lock::swap:0;
+        }
+        bool operator!() const
+        {
+            return !owns_lock();
+        }
+        bool owns_lock() const
+        {
+            return exclusive.owns_lock();
+        }
+    };
+}
+
+#endif

include/boost/thread/mutex.hpp

@@ -1,170 +1,15 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+#ifndef BOOST_THREAD_MUTEX_HPP
+#define BOOST_THREAD_MUTEX_HPP
+
+//  mutex.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 
+//
+//  Distributed under the 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_MUTEX_WEK070601_HPP
-#define BOOST_MUTEX_WEK070601_HPP
+#include <boost/thread/detail/platform.hpp>
+#include BOOST_THREAD_PLATFORM(mutex.hpp)
 
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/thread/detail/lock.hpp>
-
-#if defined(BOOST_HAS_PTHREADS)
-#   include <pthread.h>
 #endif
-
-#if defined(BOOST_HAS_MPTASKS)
-#   include "scoped_critical_region.hpp"
-#endif
-
-namespace boost {
-
-struct xtime;
-// disable warnings about non dll import
-// see: http://www.boost.org/more/separate_compilation.html#dlls
-#ifdef BOOST_MSVC
-#   pragma warning(push)
-#   pragma warning(disable: 4251 4231 4660 4275)
-#endif
-
-class BOOST_THREAD_DECL mutex
-    : private noncopyable
-{
-public:
-    friend class detail::thread::lock_ops<mutex>;
-
-    typedef detail::thread::scoped_lock<mutex> scoped_lock;
-
-    mutex();
-    ~mutex();
-
-private:
-#if defined(BOOST_HAS_WINTHREADS)
-    typedef void* cv_state;
-#elif defined(BOOST_HAS_PTHREADS)
-    struct cv_state
-    {
-        pthread_mutex_t* pmutex;
-    };
-#elif defined(BOOST_HAS_MPTASKS)
-    struct cv_state
-    {
-    };
-#endif
-    void do_lock();
-    void do_unlock();
-    void do_lock(cv_state& state);
-    void do_unlock(cv_state& state);
-
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_mutex;
-    bool m_critical_section;
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_mutex_t m_mutex;
-#elif defined(BOOST_HAS_MPTASKS)
-    threads::mac::detail::scoped_critical_region m_mutex;
-    threads::mac::detail::scoped_critical_region m_mutex_mutex;
-#endif
-};
-
-class BOOST_THREAD_DECL try_mutex
-    : private noncopyable
-{
-public:
-    friend class detail::thread::lock_ops<try_mutex>;
-
-    typedef detail::thread::scoped_lock<try_mutex> scoped_lock;
-    typedef detail::thread::scoped_try_lock<try_mutex> scoped_try_lock;
-
-    try_mutex();
-    ~try_mutex();
-
-private:
-#if defined(BOOST_HAS_WINTHREADS)
-    typedef void* cv_state;
-#elif defined(BOOST_HAS_PTHREADS)
-    struct cv_state
-    {
-        pthread_mutex_t* pmutex;
-    };
-#elif defined(BOOST_HAS_MPTASKS)
-    struct cv_state
-    {
-    };
-#endif
-    void do_lock();
-    bool do_trylock();
-    void do_unlock();
-    void do_lock(cv_state& state);
-    void do_unlock(cv_state& state);
-
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_mutex;
-    bool m_critical_section;
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_mutex_t m_mutex;
-#elif defined(BOOST_HAS_MPTASKS)
-    threads::mac::detail::scoped_critical_region m_mutex;
-    threads::mac::detail::scoped_critical_region m_mutex_mutex;
-#endif
-};
-
-class BOOST_THREAD_DECL timed_mutex
-    : private noncopyable
-{
-public:
-    friend class detail::thread::lock_ops<timed_mutex>;
-
-    typedef detail::thread::scoped_lock<timed_mutex> scoped_lock;
-    typedef detail::thread::scoped_try_lock<timed_mutex> scoped_try_lock;
-    typedef detail::thread::scoped_timed_lock<timed_mutex> scoped_timed_lock;
-
-    timed_mutex();
-    ~timed_mutex();
-
-private:
-#if defined(BOOST_HAS_WINTHREADS)
-    typedef void* cv_state;
-#elif defined(BOOST_HAS_PTHREADS)
-    struct cv_state
-    {
-        pthread_mutex_t* pmutex;
-    };
-#elif defined(BOOST_HAS_MPTASKS)
-    struct cv_state
-    {
-    };
-#endif
-    void do_lock();
-    bool do_trylock();
-    bool do_timedlock(const xtime& xt);
-    void do_unlock();
-    void do_lock(cv_state& state);
-    void do_unlock(cv_state& state);
-
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_mutex;
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_mutex_t m_mutex;
-    pthread_cond_t m_condition;
-    bool m_locked;
-#elif defined(BOOST_HAS_MPTASKS)
-    threads::mac::detail::scoped_critical_region m_mutex;
-    threads::mac::detail::scoped_critical_region m_mutex_mutex;
-#endif
-};
-#ifdef BOOST_MSVC
-#   pragma warning(pop)
-#endif
-} // namespace boost
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//   22 May 01  WEKEMPF Modified to use xtime for time outs.  Factored out
-//                      to three classes, mutex, try_mutex and timed_mutex.
-//    3 Jan 03  WEKEMPF Modified for DLL implementation.
-
-#endif // BOOST_MUTEX_WEK070601_HPP

include/boost/thread/once.hpp

@@ -1,37 +1,23 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+#ifndef BOOST_THREAD_ONCE_HPP
+#define BOOST_THREAD_ONCE_HPP
+
+//  once.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 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)
 
-#ifndef BOOST_ONCE_WEK080101_HPP
-#define BOOST_ONCE_WEK080101_HPP
+#include <boost/thread/detail/platform.hpp>
+#include BOOST_THREAD_PLATFORM(once.hpp)
 
-#include <boost/thread/detail/config.hpp>
-
-#if defined(BOOST_HAS_PTHREADS)
-#   include <pthread.h>
-#endif
-
-namespace boost {
-
-#if defined(BOOST_HAS_PTHREADS)
-
-typedef pthread_once_t once_flag;
-#define BOOST_ONCE_INIT PTHREAD_ONCE_INIT
-
-#elif (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-
-typedef long once_flag;
-#define BOOST_ONCE_INIT 0
+namespace boost
+{
+    inline void call_once(void (*func)(),once_flag& flag)
+    {
+        call_once(flag,func);
+    }
+}
 
 #endif
-
-void BOOST_THREAD_DECL call_once(void (*func)(), once_flag& flag);
-
-} // namespace boost
-
-// Change Log:
-//   1 Aug 01  WEKEMPF Initial version.
-
-#endif // BOOST_ONCE_WEK080101_HPP

include/boost/thread/pthread/condition_variable.hpp

@@ -0,0 +1,168 @@
+#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 Anthony Williams
+
+#include <boost/thread/mutex.hpp>
+#include <limits.h>
+#include <boost/assert.hpp>
+#include <algorithm>
+#include <boost/thread/thread_time.hpp>
+#include <pthread.h>
+#include "timespec.hpp"
+#include "pthread_mutex_scoped_lock.hpp"
+#include "thread_data.hpp"
+#include "condition_variable_fwd.hpp"
+
+namespace boost
+{
+    inline condition_variable::condition_variable()
+    {
+        int const res=pthread_cond_init(&cond,NULL);
+        if(res)
+        {
+            throw thread_resource_error();
+        }
+    }
+    inline condition_variable::~condition_variable()
+    {
+        BOOST_VERIFY(!pthread_cond_destroy(&cond));
+    }
+
+    inline void condition_variable::wait(unique_lock<mutex>& m)
+    {
+        detail::interruption_checker check_for_interruption(&cond);
+        BOOST_VERIFY(!pthread_cond_wait(&cond,m.mutex()->native_handle()));
+    }
+
+    inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
+    {
+        detail::interruption_checker check_for_interruption(&cond);
+        struct timespec const timeout=detail::get_timespec(wait_until);
+        int const cond_res=pthread_cond_timedwait(&cond,m.mutex()->native_handle(),&timeout);
+        if(cond_res==ETIMEDOUT)
+        {
+            return false;
+        }
+        BOOST_ASSERT(!cond_res);
+        return true;
+    }
+
+    inline void condition_variable::notify_one()
+    {
+        BOOST_VERIFY(!pthread_cond_signal(&cond));
+    }
+        
+    inline void condition_variable::notify_all()
+    {
+        BOOST_VERIFY(!pthread_cond_broadcast(&cond));
+    }
+    
+    class condition_variable_any
+    {
+        pthread_mutex_t internal_mutex;
+        pthread_cond_t cond;
+
+        condition_variable_any(condition_variable&);
+        condition_variable_any& operator=(condition_variable&);
+
+    public:
+        condition_variable_any()
+        {
+            int const res=pthread_mutex_init(&internal_mutex,NULL);
+            if(res)
+            {
+                throw thread_resource_error();
+            }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+                throw 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;
+            {
+                detail::interruption_checker check_for_interruption(&cond);
+                {
+                    boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+                    m.unlock();
+                    res=pthread_cond_wait(&cond,&internal_mutex);
+                }
+                m.lock();
+            }
+            if(res)
+            {
+                throw 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;
+            {
+                detail::interruption_checker check_for_interruption(&cond);
+                {
+                    boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+                    m.unlock();
+                    res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+                }
+                m.lock();
+            }
+            if(res==ETIMEDOUT)
+            {
+                return false;
+            }
+            if(res)
+            {
+                throw condition_error();
+            }
+            return true;
+        }
+
+        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 false;
+            }
+            return true;
+        }
+
+        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));
+        }
+    };
+
+}
+
+#endif

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -0,0 +1,52 @@
+#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 Anthony Williams
+
+#include <pthread.h>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/thread_time.hpp>
+
+namespace boost
+{
+    class condition_variable
+    {
+    private:
+        pthread_cond_t cond;
+        
+        condition_variable(condition_variable&);
+        condition_variable& operator=(condition_variable&);
+
+    public:
+        condition_variable();
+        ~condition_variable();
+
+        void wait(unique_lock<mutex>& m);
+
+        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);
+
+        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 false;
+            }
+            return true;
+        }
+
+        void notify_one();
+        void notify_all();
+    };
+}
+
+#endif

include/boost/thread/pthread/mutex.hpp

@@ -0,0 +1,197 @@
+#ifndef BOOST_THREAD_PTHREAD_MUTEX_HPP
+#define BOOST_THREAD_PTHREAD_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 <pthread.h>
+#include <boost/utility.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 <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
+
+namespace boost
+{
+    class mutex:
+        boost::noncopyable
+    {
+    private:
+        pthread_mutex_t m;
+    public:
+        mutex()
+        {
+            int const res=pthread_mutex_init(&m,NULL);
+            if(res)
+            {
+                throw thread_resource_error();
+            }
+        }
+        ~mutex()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+        }
+        
+        void lock()
+        {
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
+        }
+
+        void unlock()
+        {
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+        }
+        
+        bool try_lock()
+        {
+            int const res=pthread_mutex_trylock(&m);
+            BOOST_ASSERT(!res || res==EBUSY);
+            return !res;
+        }
+
+        typedef pthread_mutex_t* native_handle_type;
+        native_handle_type native_handle()
+        {
+            return &m;
+        }
+
+        typedef unique_lock<mutex> scoped_lock;
+        typedef scoped_lock scoped_try_lock;
+    };
+
+    typedef mutex try_mutex;
+
+    class timed_mutex:
+        boost::noncopyable
+    {
+    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)
+            {
+                throw thread_resource_error();
+            }
+#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                throw thread_resource_error();
+            }
+            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);
+        }
+
+#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==EBUSY);
+            return !res;
+        }
+#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 scoped_timed_lock scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+
+}
+
+
+#endif

include/boost/thread/pthread/once.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_THREAD_PTHREAD_ONCE_HPP
+#define BOOST_THREAD_PTHREAD_ONCE_HPP
+
+//  once.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/config.hpp>
+
+#include <pthread.h>
+#include <boost/assert.hpp>
+#include "pthread_mutex_scoped_lock.hpp"
+
+namespace boost {
+
+    struct once_flag
+    {
+        pthread_mutex_t mutex;
+        unsigned long flag;
+    };
+
+#define BOOST_ONCE_INIT {PTHREAD_MUTEX_INITIALIZER,0}
+
+    template<typename Function>
+    void call_once(once_flag& flag,Function f)
+    {
+        unsigned long const function_complete_flag_value=0xc15730e2ul;
+
+#ifdef BOOST_PTHREAD_HAS_ATOMICS
+        if(::boost::detail::interlocked_read_acquire(&flag.flag)!=function_complete_flag_value)
+        {
+#endif
+            pthread::pthread_mutex_scoped_lock const lock(&flag.mutex);
+            if(flag.flag!=function_complete_flag_value)
+            {
+                f();
+#ifdef BOOST_PTHREAD_HAS_ATOMICS
+                ::boost::detail::interlocked_write_release(&flag.flag,function_complete_flag_value);
+#else
+                flag.flag=function_complete_flag_value;
+#endif
+            }
+#ifdef BOOST_PTHREAD_HAS_ATOMICS
+        }
+#endif
+    }
+    
+
+}
+
+#endif

include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp

@@ -0,0 +1,34 @@
+#ifndef BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
+#define BOOST_PTHREAD_MUTEX_SCOPED_LOCK_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 <pthread.h>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+    namespace pthread
+    {
+        class pthread_mutex_scoped_lock
+        {
+            pthread_mutex_t* m;
+        public:
+            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
+                m(m_)
+            {
+                BOOST_VERIFY(!pthread_mutex_lock(m));
+            }
+            ~pthread_mutex_scoped_lock()
+            {
+                BOOST_VERIFY(!pthread_mutex_unlock(m));
+            }
+            
+        };
+    }
+}
+
+#endif

include/boost/thread/pthread/recursive_mutex.hpp

@@ -0,0 +1,249 @@
+#ifndef BOOST_THREAD_PTHREAD_RECURSIVE_MUTEX_HPP
+#define BOOST_THREAD_PTHREAD_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 <pthread.h>
+#include <boost/utility.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
+
+namespace boost
+{
+    class recursive_mutex:
+        boost::noncopyable
+    {
+    private:
+        pthread_mutex_t m;
+    public:
+        recursive_mutex()
+        {
+            pthread_mutexattr_t attr;
+            
+            int const init_attr_res=pthread_mutexattr_init(&attr);
+            if(init_attr_res)
+            {
+                throw thread_resource_error();
+            }
+            int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
+            if(set_attr_res)
+            {
+                throw thread_resource_error();
+            }
+            
+            int const res=pthread_mutex_init(&m,&attr);
+            if(res)
+            {
+                throw thread_resource_error();
+            }
+            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+        }
+        ~recursive_mutex()
+        {
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+        }
+        
+        void lock()
+        {
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
+        }
+
+        void unlock()
+        {
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+        }
+        
+        bool try_lock()
+        {
+            int const res=pthread_mutex_trylock(&m);
+            BOOST_ASSERT(!res || res==EBUSY);
+            return !res;
+        }
+        typedef unique_lock<recursive_mutex> scoped_lock;
+        typedef scoped_lock scoped_try_lock;
+    };
+
+    typedef recursive_mutex recursive_try_mutex;
+
+    class recursive_timed_mutex:
+        boost::noncopyable
+    {
+    private:
+        pthread_mutex_t m;
+#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+        pthread_cond_t cond;
+        bool is_locked;
+        pthread_t owner;
+        unsigned count;
+#endif
+    public:
+        recursive_timed_mutex()
+        {
+#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
+            pthread_mutexattr_t attr;
+            
+            int const init_attr_res=pthread_mutexattr_init(&attr);
+            if(init_attr_res)
+            {
+                throw thread_resource_error();
+            }
+            int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
+            if(set_attr_res)
+            {
+                throw thread_resource_error();
+            }
+            
+            int const res=pthread_mutex_init(&m,&attr);
+            if(res)
+            {
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+                throw thread_resource_error();
+            }
+            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+#else
+            int const res=pthread_mutex_init(&m,NULL);
+            if(res)
+            {
+                throw thread_resource_error();
+            }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                throw thread_resource_error();
+            }
+            is_locked=false;
+            count=0;
+#endif
+        }
+        ~recursive_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);
+        }
+
+#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==EBUSY);
+            return !res;
+        }
+#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 scoped_timed_lock scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+
+}
+
+
+#endif

include/boost/thread/pthread/shared_mutex.hpp

@@ -0,0 +1,307 @@
+#ifndef BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP
+#define BOOST_THREAD_PTHREAD_SHARED_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/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/condition_variable.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};
+            state=state_;
+        }
+
+        ~shared_mutex()
+        {
+        }
+
+        void lock_shared()
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lock(state_change);
+                
+            while(true)
+            {
+                if(!state.exclusive && !state.exclusive_waiting_blocked)
+                {
+                    ++state.shared_count;
+                    return;
+                }
+                
+                shared_cond.wait(lock);
+            }
+        }
+
+        bool try_lock_shared()
+        {
+            boost::mutex::scoped_lock lock(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 lock(state_change);
+                
+            while(true)
+            {
+                if(!state.exclusive && !state.exclusive_waiting_blocked)
+                {
+                    ++state.shared_count;
+                    return true;
+                }
+                
+                if(!shared_cond.timed_wait(lock,timeout))
+                {
+                    return false;
+                }
+            }
+        }
+
+        void unlock_shared()
+        {
+            boost::mutex::scoped_lock lock(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 lock(state_change);
+                
+            while(true)
+            {
+                if(state.shared_count || state.exclusive)
+                {
+                    state.exclusive_waiting_blocked=true;
+                }
+                else
+                {
+                    state.exclusive=true;
+                    return;
+                }
+                exclusive_cond.wait(lock);
+            }
+        }
+
+        bool timed_lock(system_time const& timeout)
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lock(state_change);
+                
+            while(true)
+            {
+                if(state.shared_count || state.exclusive)
+                {
+                    state.exclusive_waiting_blocked=true;
+                }
+                else
+                {
+                    state.exclusive=true;
+                    return true;
+                }
+                if(!exclusive_cond.timed_wait(lock,timeout))
+                {
+                    return false;
+                }
+            }
+        }
+
+        bool try_lock()
+        {
+            boost::mutex::scoped_lock lock(state_change);
+                
+            if(state.shared_count || state.exclusive)
+            {
+                return false;
+            }
+            else
+            {
+                state.exclusive=true;
+                return true;
+            }
+                
+        }
+
+        void unlock()
+        {
+            boost::mutex::scoped_lock lock(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 lock(state_change);
+            while(true)
+            {
+                if(!state.exclusive && !state.exclusive_waiting_blocked && !state.upgrade)
+                {
+                    ++state.shared_count;
+                    state.upgrade=true;
+                    return;
+                }
+                
+                shared_cond.wait(lock);
+            }
+        }
+
+        bool timed_lock_upgrade(system_time const& timeout)
+        {
+            boost::this_thread::disable_interruption do_not_disturb;
+            boost::mutex::scoped_lock lock(state_change);
+            while(true)
+            {
+                if(!state.exclusive && !state.exclusive_waiting_blocked && !state.upgrade)
+                {
+                    ++state.shared_count;
+                    state.upgrade=true;
+                    return true;
+                }
+                
+                if(!shared_cond.timed_wait(lock,timeout))
+                {
+                    return false;
+                }
+            }
+        }
+
+        bool try_lock_upgrade()
+        {
+            boost::mutex::scoped_lock lock(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 lock(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 lock(state_change);
+            --state.shared_count;
+            while(true)
+            {
+                if(!state.shared_count)
+                {
+                    state.upgrade=false;
+                    state.exclusive=true;
+                    break;
+                }
+                upgrade_cond.wait(lock);
+            }
+        }
+
+        void unlock_and_lock_upgrade()
+        {
+            boost::mutex::scoped_lock lock(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 lock(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 lock(state_change);
+            state.upgrade=false;
+            state.exclusive_waiting_blocked=false;
+            release_waiters();
+        }
+    };
+}
+
+
+#endif

include/boost/thread/pthread/thread.hpp

@@ -0,0 +1,289 @@
+#ifndef BOOST_THREAD_THREAD_PTHREAD_HPP
+#define BOOST_THREAD_THREAD_PTHREAD_HPP
+// 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/utility.hpp>
+#include <boost/function.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <list>
+#include <memory>
+
+#include <pthread.h>
+#include <boost/optional.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/shared_ptr.hpp>
+#include "thread_data.hpp"
+
+namespace boost
+{
+    class thread;
+
+    namespace detail
+    {
+        class thread_id;
+    }
+    
+    namespace this_thread
+    {
+        BOOST_THREAD_DECL detail::thread_id get_id();
+    }
+    
+    namespace detail
+    {
+        class thread_id
+        {
+            boost::optional<pthread_t> id;
+
+            friend class boost::thread;
+
+            friend thread_id this_thread::get_id();
+
+            thread_id(pthread_t id_):
+                id(id_)
+            {}
+        
+        public:
+            thread_id()
+            {}
+
+            bool operator==(const thread_id& y) const
+            {
+                return (id && y.id) && (pthread_equal(*id,*y.id)!=0);
+            }
+        
+            bool operator!=(const thread_id& y) const
+            {
+                return !(*this==y);
+            }
+
+            template<class charT, class traits>
+            friend std::basic_ostream<charT, traits>& 
+            operator<<(std::basic_ostream<charT, traits>& os, const thread_id& x)
+            {
+                if(x.id)
+                {
+                    return os<<*x.id;
+                }
+                else
+                {
+                    return os<<"{Not-any-thread}";
+                }
+            }
+        
+        };
+    }
+
+    struct xtime;
+    class BOOST_THREAD_DECL thread
+    {
+    private:
+        thread(thread&);
+        thread& operator=(thread&);
+
+        template<typename F>
+        struct thread_data:
+            detail::thread_data_base
+        {
+            F f;
+
+            thread_data(F f_):
+                f(f_)
+            {}
+            thread_data(boost::move_t<F> f_):
+                f(f_)
+            {}
+            
+            void run()
+            {
+                f();
+            }
+        };
+        
+        mutable boost::mutex thread_info_mutex;
+        boost::shared_ptr<detail::thread_data_base> thread_info;
+
+        void start_thread();
+        
+        explicit thread(boost::shared_ptr<detail::thread_data_base> data);
+
+        boost::shared_ptr<detail::thread_data_base> get_thread_info() const;
+        
+    public:
+        thread();
+        ~thread();
+
+        template <class F>
+        explicit thread(F f):
+            thread_info(new thread_data<F>(f))
+        {
+            start_thread();
+        }
+        template <class F>
+        thread(boost::move_t<F> f):
+            thread_info(new thread_data<F>(f))
+        {
+            start_thread();
+        }
+
+        explicit thread(boost::move_t<thread> x);
+        thread& operator=(boost::move_t<thread> x);
+        operator boost::move_t<thread>();
+        boost::move_t<thread> move();
+
+        void swap(thread& x);
+
+        typedef detail::thread_id 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();
+
+        // backwards compatibility
+        bool operator==(const thread& other) const;
+        bool operator!=(const thread& other) const;
+
+        static void sleep(const system_time& xt);
+        static void yield();
+
+        // extensions
+        void interrupt();
+        bool interruption_requested() const;
+    };
+
+    template<typename F>
+    struct thread::thread_data<boost::reference_wrapper<F> >:
+        detail::thread_data_base
+    {
+        F& f;
+        
+        thread_data(boost::reference_wrapper<F> f_):
+            f(f_)
+        {}
+        
+        void run()
+        {
+            f();
+        }
+    };
+
+    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();
+        };
+
+        BOOST_THREAD_DECL inline thread::id get_id()
+        {
+            return thread::id(pthread_self());
+        }
+
+        BOOST_THREAD_DECL void interruption_point();
+        BOOST_THREAD_DECL bool interruption_enabled();
+        BOOST_THREAD_DECL bool interruption_requested();
+
+        BOOST_THREAD_DECL inline void yield()
+        {
+            thread::yield();
+        }
+        
+        template<typename TimeDuration>
+        BOOST_THREAD_DECL inline void sleep(TimeDuration const& rel_time)
+        {
+            thread::sleep(get_system_time()+rel_time);
+        }
+    }
+
+    namespace detail
+    {
+        struct thread_exit_function_base
+        {
+            virtual ~thread_exit_function_base()
+            {}
+            virtual void operator()() const=0;
+        };
+        
+        template<typename F>
+        struct thread_exit_function:
+            thread_exit_function_base
+        {
+            F f;
+            
+            thread_exit_function(F f_):
+                f(f_)
+            {}
+            
+            void operator()() const
+            {
+                f();
+            }
+        };
+        
+        BOOST_THREAD_DECL void add_thread_exit_function(thread_exit_function_base*);
+    }
+    
+    namespace this_thread
+    {
+        template<typename F>
+        inline void at_thread_exit(F f)
+        {
+            detail::thread_exit_function_base* const thread_exit_func=new detail::thread_exit_function<F>(f);
+            detail::add_thread_exit_function(thread_exit_func);
+        }
+    }
+
+    class BOOST_THREAD_DECL thread_group : private noncopyable
+    {
+    public:
+        thread_group();
+        ~thread_group();
+
+        thread* create_thread(const function0<void>& threadfunc);
+        void add_thread(thread* thrd);
+        void remove_thread(thread* thrd);
+        void join_all();
+        int size() const;
+
+    private:
+        std::list<thread*> m_threads;
+        mutex m_mutex;
+    };
+} // namespace boost
+
+
+#endif

include/boost/thread/pthread/thread_data.hpp

@@ -0,0 +1,93 @@
+#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/shared_ptr.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/optional.hpp>
+#include <pthread.h>
+#include "condition_variable_fwd.hpp"
+
+namespace boost
+{
+    class thread_interrupted
+    {};
+
+    namespace detail
+    {
+        struct thread_exit_callback_node;
+        
+        struct thread_data_base
+        {
+            boost::shared_ptr<thread_data_base> 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;
+            bool interrupt_enabled;
+            bool interrupt_requested;
+            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()
+            {}
+
+            virtual void run()=0;
+        };
+
+        BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
+
+        class interruption_checker
+        {
+            thread_data_base* const thread_info;
+
+            void check_for_interruption()
+            {
+                if(thread_info->interrupt_requested)
+                {
+                    thread_info->interrupt_requested=false;
+                    throw thread_interrupted();
+                }
+            }
+            
+        public:
+            explicit interruption_checker(pthread_cond_t* cond):
+                thread_info(detail::get_current_thread_data())
+            {
+                if(thread_info && thread_info->interrupt_enabled)
+                {
+                    lock_guard<mutex> guard(thread_info->data_mutex);
+                    check_for_interruption();
+                    thread_info->current_cond=cond;
+                }
+            }
+            ~interruption_checker()
+            {
+                if(thread_info && thread_info->interrupt_enabled)
+                {
+                    lock_guard<mutex> guard(thread_info->data_mutex);
+                    thread_info->current_cond=NULL;
+                    check_for_interruption();
+                }
+            }
+        };
+    }
+}
+
+
+#endif

include/boost/thread/pthread/timespec.hpp

@@ -0,0 +1,28 @@
+#ifndef BOOST_THREAD_PTHREAD_TIMESPEC_HPP
+#define BOOST_THREAD_PTHREAD_TIMESPEC_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/thread_time.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        inline struct timespec get_timespec(boost::system_time const& abs_time)
+        {
+            struct timespec timeout={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=time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second());
+            return timeout;
+        }
+    }
+}
+
+#endif

include/boost/thread/recursive_mutex.hpp

@@ -1,184 +1,15 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+#ifndef BOOST_THREAD_RECURSIVE_MUTEX_HPP
+#define BOOST_THREAD_RECURSIVE_MUTEX_HPP
+
+//  recursive_mutex.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 
+//
+//  Distributed under the 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_RECURSIVE_MUTEX_WEK070601_HPP
-#define BOOST_RECURSIVE_MUTEX_WEK070601_HPP
+#include <boost/thread/detail/platform.hpp>
+#include BOOST_THREAD_PLATFORM(recursive_mutex.hpp)
 
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/thread/detail/lock.hpp>
-
-#if defined(BOOST_HAS_PTHREADS)
-#   include <pthread.h>
 #endif
-
-#if defined(BOOST_HAS_MPTASKS)
-#   include "scoped_critical_region.hpp"
-#endif
-
-namespace boost {
-
-struct xtime;
-// disable warnings about non dll import
-// see: http://www.boost.org/more/separate_compilation.html#dlls
-#ifdef BOOST_MSVC
-#   pragma warning(push)
-#   pragma warning(disable: 4251 4231 4660 4275)
-#endif
-class BOOST_THREAD_DECL recursive_mutex
-    : private noncopyable
-{
-public:
-    friend class detail::thread::lock_ops<recursive_mutex>;
-
-    typedef detail::thread::scoped_lock<recursive_mutex> scoped_lock;
-
-    recursive_mutex();
-    ~recursive_mutex();
-
-private:
-#if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-    typedef std::size_t cv_state;
-#elif defined(BOOST_HAS_PTHREADS)
-    struct cv_state
-    {
-        long count;
-        pthread_mutex_t* pmutex;
-    };
-#endif
-    void do_lock();
-    void do_unlock();
-    void do_lock(cv_state& state);
-    void do_unlock(cv_state& state);
-
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_mutex;
-    bool m_critical_section;
-    unsigned long m_count;
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_mutex_t m_mutex;
-    unsigned m_count;
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    pthread_cond_t m_unlocked;
-    pthread_t m_thread_id;
-    bool m_valid_id;
-#   endif
-#elif defined(BOOST_HAS_MPTASKS)
-    threads::mac::detail::scoped_critical_region m_mutex;
-    threads::mac::detail::scoped_critical_region m_mutex_mutex;
-    std::size_t m_count;
-#endif
-};
-
-class BOOST_THREAD_DECL recursive_try_mutex
-    : private noncopyable
-{
-public:
-    friend class detail::thread::lock_ops<recursive_try_mutex>;
-
-    typedef detail::thread::scoped_lock<recursive_try_mutex> scoped_lock;
-    typedef detail::thread::scoped_try_lock<
-        recursive_try_mutex> scoped_try_lock;
-
-    recursive_try_mutex();
-    ~recursive_try_mutex();
-
-private:
-#if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-    typedef std::size_t cv_state;
-#elif defined(BOOST_HAS_PTHREADS)
-    struct cv_state
-    {
-        long count;
-        pthread_mutex_t* pmutex;
-    };
-#endif
-    void do_lock();
-    bool do_trylock();
-    void do_unlock();
-    void do_lock(cv_state& state);
-    void do_unlock(cv_state& state);
-
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_mutex;
-    bool m_critical_section;
-    unsigned long m_count;
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_mutex_t m_mutex;
-    unsigned m_count;
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    pthread_cond_t m_unlocked;
-    pthread_t m_thread_id;
-    bool m_valid_id;
-#   endif
-#elif defined(BOOST_HAS_MPTASKS)
-    threads::mac::detail::scoped_critical_region m_mutex;
-    threads::mac::detail::scoped_critical_region m_mutex_mutex;
-    std::size_t m_count;
-#endif
-};
-
-class BOOST_THREAD_DECL recursive_timed_mutex
-    : private noncopyable
-{
-public:
-    friend class detail::thread::lock_ops<recursive_timed_mutex>;
-
-    typedef detail::thread::scoped_lock<recursive_timed_mutex> scoped_lock;
-    typedef detail::thread::scoped_try_lock<
-        recursive_timed_mutex> scoped_try_lock;
-    typedef detail::thread::scoped_timed_lock<
-        recursive_timed_mutex> scoped_timed_lock;
-
-    recursive_timed_mutex();
-    ~recursive_timed_mutex();
-
-private:
-#if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
-    typedef std::size_t cv_state;
-#elif defined(BOOST_HAS_PTHREADS)
-    struct cv_state
-    {
-        long count;
-        pthread_mutex_t* pmutex;
-    };
-#endif
-    void do_lock();
-    bool do_trylock();
-    bool do_timedlock(const xtime& xt);
-    void do_unlock();
-    void do_lock(cv_state& state);
-    void do_unlock(cv_state& state);
-
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_mutex;
-    unsigned long m_count;
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_mutex_t m_mutex;
-    pthread_cond_t m_unlocked;
-    pthread_t m_thread_id;
-    bool m_valid_id;
-    unsigned m_count;
-#elif defined(BOOST_HAS_MPTASKS)
-    threads::mac::detail::scoped_critical_region m_mutex;
-    threads::mac::detail::scoped_critical_region m_mutex_mutex;
-    std::size_t m_count;
-#endif
-};
-#ifdef BOOST_MSVC
-#   pragma warning(pop)
-#endif
-} // namespace boost
-
-#endif // BOOST_RECURSIVE_MUTEX_WEK070601_HPP
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//    1 Jun 01  WEKEMPF Modified to use xtime for time outs.  Factored out
-//                      to three classes, mutex, try_mutex and timed_mutex.
-//   11 Jun 01  WEKEMPF Modified to use PTHREAD_MUTEX_RECURSIVE if available.
-//    3 Jan 03  WEKEMPF Modified for DLL implementation.

include/boost/thread/shared_mutex.hpp

@@ -0,0 +1,15 @@
+#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>
+#include BOOST_THREAD_PLATFORM(shared_mutex.hpp)
+
+#endif

include/boost/thread/thread.hpp

@@ -1,89 +1,15 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+#ifndef BOOST_THREAD_THREAD_HPP
+#define BOOST_THREAD_THREAD_HPP
+
+//  thread.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 
+//
+//  Distributed under the 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_WEK070601_HPP
-#define BOOST_THREAD_WEK070601_HPP
+#include <boost/thread/detail/platform.hpp>
+#include BOOST_THREAD_PLATFORM(thread.hpp)
 
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/function.hpp>
-#include <boost/thread/mutex.hpp>
-#include <list>
-#include <memory>
-
-#if defined(BOOST_HAS_PTHREADS)
-#   include <pthread.h>
-#   include <boost/thread/condition.hpp>
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <Multiprocessing.h>
 #endif
-
-namespace boost {
-
-struct xtime;
-// disable warnings about non dll import
-// see: http://www.boost.org/more/separate_compilation.html#dlls
-#ifdef BOOST_MSVC
-#   pragma warning(push)
-#   pragma warning(disable: 4251 4231 4660 4275)
-#endif
-class BOOST_THREAD_DECL thread : private noncopyable
-{
-public:
-    thread();
-    explicit thread(const function0<void>& threadfunc);
-    ~thread();
-
-    bool operator==(const thread& other) const;
-    bool operator!=(const thread& other) const;
-
-    void join();
-
-    static void sleep(const xtime& xt);
-    static void yield();
-
-private:
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_thread;
-    unsigned int m_id;
-#elif defined(BOOST_HAS_PTHREADS)
-private:
-    pthread_t m_thread;
-#elif defined(BOOST_HAS_MPTASKS)
-    MPQueueID m_pJoinQueueID;
-    MPTaskID m_pTaskID;
-#endif
-    bool m_joinable;
-};
-
-class BOOST_THREAD_DECL thread_group : private noncopyable
-{
-public:
-    thread_group();
-    ~thread_group();
-
-    thread* create_thread(const function0<void>& threadfunc);
-    void add_thread(thread* thrd);
-    void remove_thread(thread* thrd);
-    void join_all();
-        int size();
-
-private:
-    std::list<thread*> m_threads;
-    mutex m_mutex;
-};
-#ifdef BOOST_MSVC
-#   pragma warning(pop)
-#endif
-} // namespace boost
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//    1 Jun 01  WEKEMPF Added boost::thread initial implementation.
-//    3 Jul 01  WEKEMPF Redesigned boost::thread to be noncopyable.
-
-#endif // BOOST_THREAD_WEK070601_HPP

include/boost/thread/thread_time.hpp

@@ -0,0 +1,46 @@
+#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/microsec_time_clock.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+
+namespace boost
+{
+    typedef boost::posix_time::ptime system_time;
+    
+    inline system_time get_system_time()
+    {
+        return boost::date_time::microsec_clock<system_time>::universal_time();
+    }
+
+    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);
+        }
+
+    }
+    
+}
+
+#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-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 "thread_primitives.hpp"
+#include "basic_timed_mutex.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);
+            }
+            long get_active_count()
+            {
+                return mutex.get_active_count();
+            }
+
+            void unlock()
+            {
+                if(!--recursion_count)
+                {
+                    BOOST_INTERLOCKED_EXCHANGE(&locking_thread_id,0);
+                    mutex.unlock();
+                }
+            }
+
+            bool locked()
+            {
+                return mutex.locked();
+            }
+            
+        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}
+
+#endif

include/boost/thread/win32/basic_timed_mutex.hpp

@@ -0,0 +1,157 @@
+#ifndef BOOST_BASIC_TIMED_MUTEX_WIN32_HPP
+#define BOOST_BASIC_TIMED_MUTEX_WIN32_HPP
+
+//  basic_timed_mutex_win32.hpp
+//
+//  (C) Copyright 2006 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/detail/interlocked.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        struct basic_timed_mutex
+        {
+            BOOST_STATIC_CONSTANT(long,lock_flag_value=0x80000000);
+            long active_count;
+            void* event;
+
+            void initialize()
+            {
+                active_count=0;
+                event=0;
+            }
+
+            void destroy()
+            {
+                void* const old_event=BOOST_INTERLOCKED_EXCHANGE_POINTER(&event,0);
+                if(old_event)
+                {
+                    win32::CloseHandle(old_event);
+                }
+            }
+            
+          
+            bool try_lock()
+            {
+                long old_count=active_count&~lock_flag_value;
+                do
+                {
+                    long const current_count=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,(old_count+1)|lock_flag_value,old_count);
+                    if(current_count==old_count)
+                    {
+                        return true;
+                    }
+                    old_count=current_count;
+                }
+                while(!(old_count&lock_flag_value));
+                return false;
+            }
+            
+            void lock()
+            {
+                BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
+            }
+            bool timed_lock(::boost::system_time const& wait_until)
+            {
+                long old_count=active_count;
+                while(true)
+                {
+                    long const current_count=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,(old_count+1)|lock_flag_value,old_count);
+                    if(current_count==old_count)
+                    {
+                        break;
+                    }
+                    old_count=current_count;
+                }
+
+                if(old_count&lock_flag_value)
+                {
+                    bool lock_acquired=false;
+                    void* const sem=get_event();
+                    ++old_count; // we're waiting, too
+                    do
+                    {
+                        old_count-=(lock_flag_value+1); // there will be one less active thread on this mutex when it gets unlocked
+                        if(win32::WaitForSingleObject(sem,::boost::detail::get_milliseconds_until(wait_until))!=0)
+                        {
+                            BOOST_INTERLOCKED_DECREMENT(&active_count);
+                            return false;
+                        }
+                        do
+                        {
+                            long const current_count=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,old_count|lock_flag_value,old_count);
+                            if(current_count==old_count)
+                            {
+                                break;
+                            }
+                            old_count=current_count;
+                        }
+                        while(!(old_count&lock_flag_value));
+                        lock_acquired=!(old_count&lock_flag_value);
+                    }
+                    while(!lock_acquired);
+                }
+                return true;
+            }
+
+            long get_active_count()
+            {
+                return ::boost::detail::interlocked_read_acquire(&active_count);
+            }
+
+            void unlock()
+            {
+                long const offset=lock_flag_value+1;
+                long old_count=BOOST_INTERLOCKED_EXCHANGE_ADD(&active_count,(~offset)+1);
+                
+                if(old_count>offset)
+                {
+                    win32::SetEvent(get_event());
+                }
+            }
+
+            bool locked()
+            {
+                return get_active_count()>=lock_flag_value;
+            }
+            
+        private:
+            void* get_event()
+            {
+                void* current_event=::boost::detail::interlocked_read_acquire(&event);
+                
+                if(!current_event)
+                {
+                    void* const new_event=win32::create_anonymous_event(win32::auto_reset_event,win32::event_initially_reset);
+                    void* const old_event=BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&event,new_event,0);
+                    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}
+
+#endif

include/boost/thread/win32/condition_variable.hpp

@@ -0,0 +1,304 @@
+#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 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"
+
+namespace boost
+{
+    namespace detail
+    {
+        class basic_condition_variable
+        {
+            boost::mutex internal_mutex;
+            long total_count;
+            unsigned active_generation_count;
+
+            struct list_entry
+            {
+                detail::win32::handle semaphore;
+                long count;
+                bool notified;
+
+                list_entry():
+                    semaphore(0),count(0),notified(0)
+                {}
+            };
+
+            BOOST_STATIC_CONSTANT(unsigned,generation_count=3);
+
+            list_entry generations[generation_count];
+            detail::win32::handle wake_sem;
+
+            static bool no_waiters(list_entry const& entry)
+            {
+                return entry.count==0;
+            }
+
+            void shift_generations_down()
+            {
+                list_entry* const last_active_entry=std::remove_if(generations,generations+generation_count,no_waiters);
+                if(last_active_entry==generations+generation_count)
+                {
+                    broadcast_entry(generations[generation_count-1],false);
+                }
+                else
+                {
+                    active_generation_count=(last_active_entry-generations)+1;
+                }
+            
+                std::copy_backward(generations,generations+active_generation_count-1,generations+active_generation_count);
+                generations[0]=list_entry();
+            }
+
+            void broadcast_entry(list_entry& entry,bool wake)
+            {
+                long const count_to_wake=entry.count;
+                detail::interlocked_write_release(&total_count,total_count-count_to_wake);
+                if(wake)
+                {
+                    detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
+                }
+                detail::win32::ReleaseSemaphore(entry.semaphore,count_to_wake,0);
+                entry.count=0;
+                dispose_entry(entry);
+            }
+        
+
+            void dispose_entry(list_entry& entry)
+            {
+                if(entry.semaphore)
+                {
+                    BOOST_VERIFY(detail::win32::CloseHandle(entry.semaphore));
+                    entry.semaphore=0;
+                }
+                entry.notified=false;
+            }
+
+            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();
+                    }
+                    
+                }
+            };
+            
+
+        protected:
+            template<typename lock_type>
+            bool do_wait(lock_type& lock,::boost::system_time const& wait_until)
+            {
+                detail::win32::handle_manager local_wake_sem;
+                detail::win32::handle_manager sem;
+                bool first_loop=true;
+                bool woken=false;
+
+                relocker<lock_type> locker(lock);
+            
+                while(!woken)
+                {
+                    {
+                        boost::mutex::scoped_lock internal_lock(internal_mutex);
+                        detail::interlocked_write_release(&total_count,total_count+1);
+                        if(first_loop)
+                        {
+                            locker.unlock();
+                            if(!wake_sem)
+                            {
+                                wake_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+                                BOOST_ASSERT(wake_sem);
+                            }
+                            local_wake_sem=detail::win32::duplicate_handle(wake_sem);
+                        
+                            if(generations[0].notified)
+                            {
+                                shift_generations_down();
+                            }
+                            else if(!active_generation_count)
+                            {
+                                active_generation_count=1;
+                            }
+                        
+                            first_loop=false;
+                        }
+                        if(!generations[0].semaphore)
+                        {
+                            generations[0].semaphore=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+                            BOOST_ASSERT(generations[0].semaphore);
+                        }
+                        ++generations[0].count;
+                        sem=detail::win32::duplicate_handle(generations[0].semaphore);
+                    }
+                    if(!this_thread::interruptible_wait(sem,::boost::detail::get_milliseconds_until(wait_until)))
+                    {
+                        break;
+                    }
+                
+                    unsigned long const woken_result=detail::win32::WaitForSingleObject(local_wake_sem,0);
+                    BOOST_ASSERT(woken_result==detail::win32::timeout || woken_result==0);
+
+                    woken=(woken_result==0);
+                }
+                return woken;
+            }
+        
+            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()
+            {
+                for(unsigned i=0;i<generation_count;++i)
+                {
+                    dispose_entry(generations[i]);
+                }
+                detail::win32::CloseHandle(wake_sem);
+            }
+
+        
+            void notify_one()
+            {
+                if(detail::interlocked_read_acquire(&total_count))
+                {
+                    boost::mutex::scoped_lock internal_lock(internal_mutex);
+                    detail::win32::ReleaseSemaphore(wake_sem,1,0);
+                    for(unsigned generation=active_generation_count;generation!=0;--generation)
+                    {
+                        list_entry& entry=generations[generation-1];
+                        if(entry.count)
+                        {
+                            detail::interlocked_write_release(&total_count,total_count-1);
+                            entry.notified=true;
+                            detail::win32::ReleaseSemaphore(entry.semaphore,1,0);
+                            if(!--entry.count)
+                            {
+                                dispose_entry(entry);
+                                if(generation==active_generation_count)
+                                {
+                                    --active_generation_count;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        
+            void notify_all()
+            {
+                if(detail::interlocked_read_acquire(&total_count))
+                {
+                    boost::mutex::scoped_lock internal_lock(internal_mutex);
+                    for(unsigned generation=active_generation_count;generation!=0;--generation)
+                    {
+                        list_entry& entry=generations[generation-1];
+                        if(entry.count)
+                        {
+                            broadcast_entry(entry,true);
+                        }
+                    }
+                    active_generation_count=0;
+                }
+            }
+        
+        };
+    }
+
+    class condition_variable:
+        public detail::basic_condition_variable
+    {
+    public:
+        void wait(unique_lock<mutex>& m)
+        {
+            do_wait(m,::boost::detail::get_system_time_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);
+        }
+
+        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 false;
+            }
+            return true;
+        }
+    };
+    
+    class condition_variable_any:
+        public detail::basic_condition_variable
+    {
+    public:
+        template<typename lock_type>
+        void wait(lock_type& m)
+        {
+            do_wait(m,::boost::detail::get_system_time_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,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 false;
+            }
+            return true;
+        }
+    };
+
+}
+
+#endif

include/boost/thread/win32/interlocked_read.hpp

@@ -0,0 +1,77 @@
+#ifndef BOOST_THREAD_DETAIL_INTERLOCKED_READ_WIN32_HPP
+#define BOOST_THREAD_DETAIL_INTERLOCKED_READ_WIN32_HPP
+
+//  interlocked_read_win32.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)
+
+#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
+
+#include <boost/detail/interlocked.hpp>
+
+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
+
+
+#endif

include/boost/thread/win32/mutex.hpp

@@ -0,0 +1,61 @@
+#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>
+
+namespace boost
+{
+    namespace detail
+    {
+        typedef ::boost::detail::basic_timed_mutex underlying_mutex;
+    }
+
+    class mutex:
+		boost::noncopyable,
+        public ::boost::detail::underlying_mutex
+    {
+    public:
+        mutex()
+        {
+            initialize();
+        }
+        ~mutex()
+        {
+            destroy();
+        }
+
+        typedef unique_lock<mutex> scoped_lock;
+        typedef scoped_lock scoped_try_lock;
+    };
+
+    typedef mutex try_mutex;
+
+    class timed_mutex:
+        boost::noncopyable,
+        public ::boost::detail::basic_timed_mutex
+    {
+    public:
+        timed_mutex()
+        {
+            initialize();
+        }
+
+        ~timed_mutex()
+        {
+            destroy();
+        }
+
+        typedef unique_lock<timed_mutex> scoped_timed_lock;
+        typedef scoped_timed_lock scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+}
+
+#endif

include/boost/thread/win32/once.hpp

@@ -0,0 +1,130 @@
+#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>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std
+{
+    using ::memcpy;
+    using ::ptrdiff_t;
+}
+#endif
+
+namespace boost
+{
+    typedef long once_flag;
+
+#define BOOST_ONCE_INIT 0
+
+    namespace detail
+    {
+        struct win32_mutex_scoped_lock
+        {
+            void* const mutex_handle;
+            explicit win32_mutex_scoped_lock(void* mutex_handle_):
+                mutex_handle(mutex_handle_)
+            {
+                BOOST_VERIFY(!win32::WaitForSingleObject(mutex_handle,win32::infinite));
+            }
+            ~win32_mutex_scoped_lock()
+            {
+                BOOST_VERIFY(win32::ReleaseMutex(mutex_handle)!=0);
+            }
+        };
+
+#ifdef BOOST_NO_ANSI_APIS
+        template <class I>
+        void int_to_string(I p, wchar_t* buf)
+        {
+            for(unsigned i=0; i < sizeof(I)*2; ++i,++buf)
+            {
+                *buf = L'A' + static_cast<wchar_t>((p >> (i*4)) & 0x0f);
+            }
+            *buf = 0;
+        }
+#else
+        template <class I>
+        void int_to_string(I p, char* buf)
+        {
+            for(unsigned i=0; i < sizeof(I)*2; ++i,++buf)
+            {
+                *buf = 'A' + static_cast<char>((p >> (i*4)) & 0x0f);
+            }
+            *buf = 0;
+        }
+#endif
+
+        // create a named mutex. It doesn't really matter what this name is
+        // as long as it is unique both to this process, and to the address of "flag":
+        inline void* create_once_mutex(void* flag_address)
+        {
+        
+#ifdef BOOST_NO_ANSI_APIS
+            typedef wchar_t char_type;
+            static const char_type fixed_mutex_name[]=L"{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+#else
+            typedef char char_type;
+            static const char_type fixed_mutex_name[]="{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+#endif
+            unsigned const once_mutex_name_fixed_buffer_size=sizeof(fixed_mutex_name)/sizeof(char_type);
+            unsigned const once_mutex_name_fixed_length=once_mutex_name_fixed_buffer_size-1;
+            unsigned const once_mutex_name_length=once_mutex_name_fixed_buffer_size+sizeof(void*)*2+sizeof(unsigned long)*2;
+            char_type mutex_name[once_mutex_name_length];
+            
+            std::memcpy(mutex_name,fixed_mutex_name,sizeof(fixed_mutex_name));
+
+            BOOST_STATIC_ASSERT(sizeof(void*) == sizeof(std::ptrdiff_t));
+            detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address), mutex_name + once_mutex_name_fixed_length);
+            detail::int_to_string(win32::GetCurrentProcessId(), mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
+
+#ifdef BOOST_NO_ANSI_APIS
+            return win32::CreateMutexW(NULL, 0, mutex_name);
+#else
+            return win32::CreateMutexA(NULL, 0, mutex_name);
+#endif
+        }
+
+        
+    }
+    
+
+    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;
+
+        if(::boost::detail::interlocked_read_acquire(&flag)!=function_complete_flag_value)
+        {
+            void* const mutex_handle(::boost::detail::create_once_mutex(&flag));
+            BOOST_ASSERT(mutex_handle);
+            detail::win32::handle_manager const closer(mutex_handle);
+            detail::win32_mutex_scoped_lock const lock(mutex_handle);
+      
+            if(flag!=function_complete_flag_value)
+            {
+                f();
+                BOOST_INTERLOCKED_EXCHANGE(&flag,function_complete_flag_value);
+            }
+        }
+    }
+}
+
+#endif

include/boost/thread/win32/recursive_mutex.hpp

@@ -0,0 +1,61 @@
+#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>
+
+namespace boost
+{
+    class recursive_mutex:
+        boost::noncopyable,
+        public ::boost::detail::basic_recursive_mutex
+    {
+    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 scoped_lock scoped_try_lock;
+    };
+
+    typedef recursive_mutex recursive_try_mutex;
+
+    class recursive_timed_mutex:
+        boost::noncopyable,
+        public ::boost::detail::basic_recursive_timed_mutex
+    {
+    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 scoped_timed_lock scoped_try_lock;
+        typedef scoped_timed_lock scoped_lock;
+    };
+}
+
+
+#endif

include/boost/thread/win32/shared_mutex.hpp

@@ -0,0 +1,509 @@
+#ifndef BOOST_THREAD_WIN32_SHARED_MUTEX_HPP
+#define BOOST_THREAD_WIN32_SHARED_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/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>
+
+namespace boost
+{
+    class shared_mutex:
+        private boost::noncopyable
+    {
+    private:
+        struct state_data
+        {
+            unsigned shared_count:11;
+            unsigned shared_waiting:11;
+            unsigned exclusive:1;
+            unsigned upgrade:1;
+            unsigned exclusive_waiting:7;
+            unsigned 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);
+        }
+
+        state_data state;
+        void* semaphores[2];
+        void* &unlock_sem;
+        void* &exclusive_sem;
+        void* upgrade_sem;
+
+        void release_waiters(state_data old_state)
+        {
+            if(old_state.exclusive_waiting)
+            {
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(exclusive_sem,1,NULL)!=0);
+            }
+                        
+            if(old_state.shared_waiting || old_state.exclusive_waiting)
+            {
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),NULL)!=0);
+            }
+        }
+        
+
+    public:
+        shared_mutex():
+            unlock_sem(semaphores[0]),
+            exclusive_sem(semaphores[1]) 
+        {
+            unlock_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            exclusive_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            upgrade_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            state_data state_={0};
+            state=state_;
+        }
+
+        ~shared_mutex()
+        {
+            detail::win32::CloseHandle(upgrade_sem);
+            detail::win32::CloseHandle(unlock_sem);
+            detail::win32::CloseHandle(exclusive_sem);
+        }
+
+        bool try_lock_shared()
+        {
+            state_data old_state=state;
+            do
+            {
+                state_data new_state=old_state;
+                if(!new_state.exclusive && !new_state.exclusive_waiting_blocked)
+                {
+                    ++new_state.shared_count;
+                }
+                
+                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                if(current_state==old_state)
+                {
+                    break;
+                }
+                old_state=current_state;
+            }
+            while(true);
+            return !(old_state.exclusive| old_state.exclusive_waiting_blocked);
+        }
+
+        void lock_shared()
+        {
+            BOOST_VERIFY(timed_lock_shared(::boost::detail::get_system_time_sentinel()));
+        }
+
+        bool timed_lock_shared(boost::system_time const& wait_until)
+        {
+            while(true)
+            {
+                state_data old_state=state;
+                do
+                {
+                    state_data new_state=old_state;
+                    if(new_state.exclusive || new_state.exclusive_waiting_blocked)
+                    {
+                        ++new_state.shared_waiting;
+                    }
+                    else
+                    {
+                        ++new_state.shared_count;
+                    }
+
+                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                    if(current_state==old_state)
+                    {
+                        break;
+                    }
+                    old_state=current_state;
+                }
+                while(true);
+
+                if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+                {
+                    return true;
+                }
+                    
+                unsigned long const res=detail::win32::WaitForSingleObject(unlock_sem,::boost::detail::get_milliseconds_until(wait_until));
+                if(res==detail::win32::timeout)
+                {
+                    do
+                    {
+                        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;
+                        }
+
+                        state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                        if(current_state==old_state)
+                        {
+                            break;
+                        }
+                        old_state=current_state;
+                    }
+                    while(true);
+
+                    if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+                
+                BOOST_ASSERT(res==0);
+            }
+        }
+
+        void unlock_shared()
+        {
+            state_data old_state=state;
+            do
+            {
+                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,NULL)!=0);
+                        }
+                        else
+                        {
+                            release_waiters(old_state);
+                        }
+                    }
+                    break;
+                }
+                old_state=current_state;
+            }
+            while(true);
+        }
+
+        void lock()
+        {
+            BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
+        }
+
+        bool timed_lock(boost::system_time const& wait_until)
+        {
+            while(true)
+            {
+                state_data old_state=state;
+
+                do
+                {
+                    state_data new_state=old_state;
+                    if(new_state.shared_count || new_state.exclusive)
+                    {
+                        ++new_state.exclusive_waiting;
+                        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;
+                }
+                while(true);
+
+                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)
+                {
+                    do
+                    {
+                        state_data new_state=old_state;
+                        if(new_state.shared_count || new_state.exclusive)
+                        {
+                            if(new_state.exclusive_waiting)
+                            {
+                                --new_state.exclusive_waiting;
+                            }
+                        }
+                        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;
+                    }
+                    while(true);
+                    if(!old_state.shared_count && !old_state.exclusive)
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+                BOOST_ASSERT(wait_res<2);
+            }
+        }
+
+        void unlock()
+        {
+            state_data old_state=state;
+            do
+            {
+                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;
+            }
+            while(true);
+            release_waiters(old_state);
+        }
+
+        void lock_upgrade()
+        {
+            while(true)
+            {
+                state_data old_state=state;
+                do
+                {
+                    state_data new_state=old_state;
+                    if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
+                    {
+                        ++new_state.shared_waiting;
+                    }
+                    else
+                    {
+                        ++new_state.shared_count;
+                        new_state.upgrade=true;
+                    }
+
+                    state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
+                    if(current_state==old_state)
+                    {
+                        break;
+                    }
+                    old_state=current_state;
+                }
+                while(true);
+
+                if(!(old_state.exclusive|| old_state.exclusive_waiting_blocked|| old_state.upgrade))
+                {
+                    return;
+                }
+                    
+                BOOST_VERIFY(!detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite));
+            }
+        }
+
+        void unlock_upgrade()
+        {
+            state_data old_state=state;
+            do
+            {
+                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;
+            }
+            while(true);
+        }
+
+        void unlock_upgrade_and_lock()
+        {
+            state_data old_state=state;
+            do
+            {
+                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;
+            }
+            while(true);
+        }
+
+        void unlock_and_lock_upgrade()
+        {
+            state_data old_state=state;
+            do
+            {
+                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;
+            }
+            while(true);
+            release_waiters(old_state);
+        }
+        
+        void unlock_and_lock_shared()
+        {
+            state_data old_state=state;
+            do
+            {
+                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;
+            }
+            while(true);
+            release_waiters(old_state);
+        }
+        
+        void unlock_upgrade_and_lock_shared()
+        {
+            state_data old_state=state;
+            do
+            {
+                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;
+            }
+            while(true);
+            release_waiters(old_state);
+        }
+        
+    };
+}
+
+
+#endif

include/boost/thread/win32/thread.hpp

@@ -0,0 +1,442 @@
+#ifndef BOOST_THREAD_THREAD_WIN32_HPP
+#define BOOST_THREAD_THREAD_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 Anthony Williams
+
+#include <exception>
+#include <boost/thread/exceptions.hpp>
+#include <ostream>
+#include <boost/thread/detail/move.hpp>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread_time.hpp>
+#include "thread_primitives.hpp"
+#include "thread_heap_alloc.hpp"
+#include <boost/utility.hpp>
+#include <list>
+#include <algorithm>
+#include <boost/ref.hpp>
+
+namespace boost
+{
+    class thread_interrupted
+    {};
+
+    namespace detail
+    {
+        struct thread_exit_callback_node;
+        
+        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;
+            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),
+                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);
+                }
+            }
+
+            virtual void run()=0;
+        };
+    }
+
+    class BOOST_THREAD_DECL thread
+    {
+    private:
+        thread(thread&);
+        thread& operator=(thread&);
+
+        void release_handle();
+
+        template<typename F>
+        struct thread_data:
+            detail::thread_data_base
+        {
+            F f;
+
+            thread_data(F f_):
+                f(f_)
+            {}
+            thread_data(boost::move_t<F> f_):
+                f(f_)
+            {}
+            
+            void run()
+            {
+                f();
+            }
+        };
+        
+        mutable boost::mutex thread_info_mutex;
+        boost::intrusive_ptr<detail::thread_data_base> thread_info;
+
+        static unsigned __stdcall thread_start_function(void* param);
+
+        void start_thread();
+        
+        explicit thread(boost::intrusive_ptr<detail::thread_data_base> data);
+
+        boost::intrusive_ptr<detail::thread_data_base> get_thread_info() const;
+    public:
+        thread();
+        ~thread();
+
+        template <class F>
+        explicit thread(F f):
+            thread_info(detail::heap_new<thread_data<F> >(f))
+        {
+            start_thread();
+        }
+        template <class F>
+        explicit thread(boost::move_t<F> f):
+            thread_info(detail::heap_new<thread_data<F> >(f))
+        {
+            start_thread();
+        }
+
+        thread(boost::move_t<thread> x);
+        thread& operator=(boost::move_t<thread> x);
+        operator boost::move_t<thread>();
+        boost::move_t<thread> move();
+
+        void swap(thread& x);
+
+        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::win32::handle native_handle_type;
+        native_handle_type native_handle();
+
+        // backwards compatibility
+        bool operator==(const thread& other) const;
+        bool operator!=(const thread& other) const;
+
+        static void yield();
+        static void sleep(const system_time& xt);
+
+        // extensions
+        class interruption_handle;
+        interruption_handle get_interruption_handle() const;
+        void interrupt();
+        bool interruption_requested() const;
+
+        static thread self();
+    };
+
+    template<typename F>
+    struct thread::thread_data<boost::reference_wrapper<F> >:
+        detail::thread_data_base
+    {
+        F& f;
+        
+        thread_data(boost::reference_wrapper<F> f_):
+            f(f_)
+        {}
+        
+        void run()
+        {
+            f();
+        }
+    };
+    
+
+    namespace this_thread
+    {
+        class BOOST_THREAD_DECL disable_interruption
+        {
+            disable_interruption(const disable_interruption&);
+            disable_interruption& operator=(const disable_interruption&);
+            
+            bool interruption_was_enabled;
+            friend class restore_interruption;
+        public:
+            disable_interruption();
+            ~disable_interruption();
+        };
+
+        class BOOST_THREAD_DECL restore_interruption
+        {
+            restore_interruption(const restore_interruption&);
+            restore_interruption& operator=(const restore_interruption&);
+        public:
+            explicit restore_interruption(disable_interruption& d);
+            ~restore_interruption();
+        };
+
+        thread::id BOOST_THREAD_DECL get_id();
+
+        bool BOOST_THREAD_DECL interruptible_wait(detail::win32::handle handle_to_wait_for,unsigned long milliseconds);
+        inline bool interruptible_wait(unsigned long milliseconds)
+        {
+            return interruptible_wait(detail::win32::invalid_handle_value,milliseconds);
+        }
+
+        void BOOST_THREAD_DECL interruption_point();
+        bool BOOST_THREAD_DECL interruption_enabled();
+        bool BOOST_THREAD_DECL interruption_requested();
+        thread::interruption_handle BOOST_THREAD_DECL get_interruption_handle();
+
+        void BOOST_THREAD_DECL yield();
+        template<typename TimeDuration>
+        void sleep(TimeDuration const& rel_time)
+        {
+            interruptible_wait(static_cast<unsigned long>(rel_time.total_milliseconds()));
+        }
+    }
+
+    class thread::id
+    {
+    private:
+        unsigned thread_id;
+            
+        id(unsigned thread_id_):
+            thread_id(thread_id_)
+        {}
+        friend class thread;
+        friend id this_thread::get_id();
+    public:
+        id():
+            thread_id(0)
+        {}
+            
+        bool operator==(const id& y) const
+        {
+            return thread_id==y.thread_id;
+        }
+        
+        bool operator!=(const id& y) const
+        {
+            return thread_id!=y.thread_id;
+        }
+        
+        bool operator<(const id& y) const
+        {
+            return thread_id<y.thread_id;
+        }
+        
+        bool operator>(const id& y) const
+        {
+            return thread_id>y.thread_id;
+        }
+        
+        bool operator<=(const id& y) const
+        {
+            return thread_id<=y.thread_id;
+        }
+        
+        bool operator>=(const id& y) const
+        {
+            return thread_id>=y.thread_id;
+        }
+
+        template<class charT, class traits>
+        friend std::basic_ostream<charT, traits>& 
+        operator<<(std::basic_ostream<charT, traits>& os, const id& x)
+        {
+            return os<<x.thread_id;
+        }
+    };
+
+    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();
+    }
+
+    class thread::interruption_handle
+    {
+    private:
+        boost::detail::win32::handle_manager handle;
+        friend class thread;
+        friend interruption_handle this_thread::get_interruption_handle();
+
+        interruption_handle(detail::win32::handle h_):
+            handle(h_)
+        {}
+    public:
+        interruption_handle(interruption_handle const& other):
+            handle(other.handle.duplicate())
+        {}
+        interruption_handle():
+            handle(0)
+        {}
+
+        void swap(interruption_handle& other)
+        {
+            handle.swap(other.handle);
+        }
+        
+        interruption_handle& operator=(interruption_handle const& other)
+        {
+            interruption_handle temp(other);
+            swap(temp);
+            return *this;
+        }
+
+        void reset()
+        {
+            handle=0;
+        }
+
+        void interrupt()
+        {
+            if(handle)
+            {
+                detail::win32::SetEvent(handle);
+            }
+        }
+
+        typedef void(interruption_handle::*bool_type)();
+        operator bool_type() const
+        {
+            return handle?&interruption_handle::interrupt:0;
+        }
+    };
+        
+    namespace detail
+    {
+        struct thread_exit_function_base
+        {
+            virtual ~thread_exit_function_base()
+            {}
+            virtual void operator()() const=0;
+        };
+        
+        template<typename F>
+        struct thread_exit_function:
+            thread_exit_function_base
+        {
+            F f;
+            
+            thread_exit_function(F f_):
+                f(f_)
+            {}
+            
+            void operator()() const
+            {
+                f();
+            }
+        };
+        
+        void 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);
+        }
+    }
+
+    class thread_group:
+        private noncopyable
+    {
+    public:
+        ~thread_group()
+        {
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                delete *it;
+            }
+        }
+
+        template<typename F>
+        thread* create_thread(F threadfunc)
+        {
+            boost::lock_guard<mutex> guard(m);
+            thread* const new_thread=new thread(threadfunc);
+            threads.push_back(new_thread);
+            return new_thread;
+        }
+        
+        void add_thread(thread* thrd)
+        {
+            if(thrd)
+            {
+                boost::lock_guard<mutex> guard(m);
+                threads.push_back(thrd);
+            }
+        }
+            
+        void remove_thread(thread* thrd)
+        {
+            boost::lock_guard<mutex> guard(m);
+            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
+            if(it!=threads.end())
+            {
+                threads.erase(it);
+            }
+        }
+        
+        void join_all()
+        {
+            boost::lock_guard<mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->join();
+            }
+        }
+        
+        int size() const
+        {
+            boost::lock_guard<mutex> guard(m);
+            return threads.size();
+        }
+        
+    private:
+        std::list<thread*> threads;
+        mutable mutex m;
+    };
+}
+
+#endif

include/boost/thread/win32/thread_heap_alloc.hpp

@@ -0,0 +1,109 @@
+// Distributed under the 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"
+
+#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
+
+namespace boost
+{
+    namespace detail
+    {
+        template<typename T>
+        T* heap_new()
+        {
+            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,sizeof(T));
+            T* const data=new (heap_memory) T();
+            return data;
+        }
+
+        template<typename T,typename A1>
+        T* heap_new(A1 a1)
+        {
+            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,sizeof(T));
+            T* const data=new (heap_memory) T(a1);
+            return data;
+        }
+        
+        template<typename T,typename A1,typename A2>
+        T* heap_new(A1 a1,A2 a2)
+        {
+            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,sizeof(T));
+            T* const data=new (heap_memory) T(a1,a2);
+            return data;
+        }
+        
+        template<typename T>
+        void heap_delete(T* data)
+        {
+            data->~T();
+            detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,data);
+        }
+
+        template<typename T>
+        struct do_delete
+        {
+            T* data;
+            
+            do_delete(T* data_):
+                data(data_)
+            {}
+            
+            void operator()() const
+            {
+                detail::heap_delete(data);
+            }
+        };
+
+        template<typename T>
+        do_delete<T> make_heap_deleter(T* data)
+        {
+            return do_delete<T>(data);
+        }
+    }
+}
+
+
+#endif

include/boost/thread/win32/thread_primitives.hpp

@@ -0,0 +1,278 @@
+#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/assert.hpp>
+#include <boost/thread/exceptions.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;
+
+# ifdef BOOST_NO_ANSI_APIS
+            using ::CreateMutexW;
+            using ::CreateEventW;
+            using ::CreateSemaphoreW;
+# else
+            using ::CreateMutexA;
+            using ::CreateEventA;
+            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;
+        }
+    }
+}
+#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);
+
+            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*);
+# 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*);
+# 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);
+
+# 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
+
+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)
+                {
+                    throw 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(NULL,initial_count,max_count,NULL);
+#else
+                handle const res=CreateSemaphoreW(NULL,initial_count,max_count,NULL);
+#endif               
+                if(!res)
+                {
+                    throw 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)
+                {
+                    throw 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();
+                }
+            };
+            
+        }
+    }
+}
+
+
+#endif

include/boost/thread/xtime.hpp

@@ -1,5 +1,6 @@
 // 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)
@@ -10,6 +11,8 @@
 #include <boost/thread/detail/config.hpp>
 
 #include <boost/cstdint.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
 
 namespace boost {
 
@@ -37,9 +40,40 @@ struct xtime
 
     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
+    }
+    
 };
 
-int BOOST_THREAD_DECL xtime_get(struct xtime* xtp, int clock_type);
+inline xtime get_xtime(boost::system_time const& abs_time)
+{
+    xtime res={0};
+    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)
 {

src/barrier.cpp

@@ -1,42 +0,0 @@
-// Copyright (C) 2002-2003
-// David Moore, 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/barrier.hpp>
-#include <string> // see http://article.gmane.org/gmane.comp.lib.boost.devel/106981
-
-namespace boost {
-
-barrier::barrier(unsigned int count)
-    : m_threshold(count), m_count(count), m_generation(0)
-{
-    if (count == 0)
-        throw std::invalid_argument("count cannot be zero.");
-}
-
-barrier::~barrier()
-{
-}
-
-bool barrier::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;
-}
-
-} // namespace boost

src/condition.cpp

@@ -1,692 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/thread/condition.hpp>
-#include <boost/thread/xtime.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/thread/exceptions.hpp>
-#include <boost/limits.hpp>
-#include <cassert>
-#include "timeconv.inl"
-
-#if defined(BOOST_HAS_WINTHREADS)
-#   ifndef NOMINMAX
-#      define NOMINMAX
-#   endif
-#   include <windows.h>
-#elif defined(BOOST_HAS_PTHREADS)
-#   include <errno.h>
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <MacErrors.h>
-#   include "mac/init.hpp"
-#   include "mac/safe.hpp"
-#endif
-
-// The following include can be removed after the bug on QNX
-// has been tracked down. I need this only for debugging
-//#if !defined(NDEBUG) && defined(BOOST_HAS_PTHREADS)
-#include <iostream>
-//#endif
-
-namespace boost {
-
-namespace detail {
-
-#if defined(BOOST_HAS_WINTHREADS)
-condition_impl::condition_impl()
-    : m_gone(0), m_blocked(0), m_waiting(0)
-{
-    m_gate = reinterpret_cast<void*>(CreateSemaphore(0, 1, 1, 0));
-    m_queue = reinterpret_cast<void*>(
-        CreateSemaphore(0, 0, (std::numeric_limits<long>::max)(), 0));
-    m_mutex = reinterpret_cast<void*>(CreateMutex(0, 0, 0));
-
-    if (!m_gate || !m_queue || !m_mutex)
-    {
-        int res = 0;
-        if (m_gate)
-        {
-            res = CloseHandle(reinterpret_cast<HANDLE>(m_gate));
-            assert(res);
-        }
-        if (m_queue)
-        {
-            res = CloseHandle(reinterpret_cast<HANDLE>(m_queue));
-            assert(res);
-        }
-        if (m_mutex)
-        {
-            res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
-            assert(res);
-        }
-
-        throw thread_resource_error();
-    }
-}
-
-condition_impl::~condition_impl()
-{
-    int res = 0;
-    res = CloseHandle(reinterpret_cast<HANDLE>(m_gate));
-    assert(res);
-    res = CloseHandle(reinterpret_cast<HANDLE>(m_queue));
-    assert(res);
-    res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
-    assert(res);
-}
-
-void condition_impl::notify_one()
-{
-    unsigned signals = 0;
-
-    int res = 0;
-    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
-    assert(res == WAIT_OBJECT_0);
-
-    if (m_waiting != 0) // the m_gate is already closed
-    {
-        if (m_blocked == 0)
-        {
-            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-            assert(res);
-            return;
-        }
-
-        ++m_waiting;
-        --m_blocked;
-        signals = 1;
-    }
-    else
-    {
-        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-        assert(res == WAIT_OBJECT_0);
-        if (m_blocked > m_gone)
-        {
-            if (m_gone != 0)
-            {
-                m_blocked -= m_gone;
-                m_gone = 0;
-            }
-            signals = m_waiting = 1;
-            --m_blocked;
-        }
-        else
-        {
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-            assert(res);
-        }
-    }
-
-    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-    assert(res);
-
-    if (signals)
-    {
-        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
-        assert(res);
-    }
-}
-
-void condition_impl::notify_all()
-{
-    unsigned signals = 0;
-
-    int res = 0;
-    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
-    assert(res == WAIT_OBJECT_0);
-
-    if (m_waiting != 0) // the m_gate is already closed
-    {
-        if (m_blocked == 0)
-        {
-            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-            assert(res);
-            return;
-        }
-
-        m_waiting += (signals = m_blocked);
-        m_blocked = 0;
-    }
-    else
-    {
-        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-        assert(res == WAIT_OBJECT_0);
-        if (m_blocked > m_gone)
-        {
-            if (m_gone != 0)
-            {
-                m_blocked -= m_gone;
-                m_gone = 0;
-            }
-            signals = m_waiting = m_blocked;
-            m_blocked = 0;
-        }
-        else
-        {
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-            assert(res);
-        }
-    }
-
-    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-    assert(res);
-
-    if (signals)
-    {
-        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
-        assert(res);
-    }
-}
-
-void condition_impl::enter_wait()
-{
-    int res = 0;
-    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-    assert(res == WAIT_OBJECT_0);
-    ++m_blocked;
-    res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-    assert(res);
-}
-
-void condition_impl::do_wait()
-{
-    int res = 0;
-    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), INFINITE);
-    assert(res == WAIT_OBJECT_0);
-
-    unsigned was_waiting=0;
-    unsigned was_gone=0;
-
-    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
-    assert(res == WAIT_OBJECT_0);
-    was_waiting = m_waiting;
-    was_gone = m_gone;
-    if (was_waiting != 0)
-    {
-        if (--m_waiting == 0)
-        {
-            if (m_blocked != 0)
-            {
-                res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1,
-                    0); // open m_gate
-                assert(res);
-                was_waiting = 0;
-            }
-            else if (m_gone != 0)
-                m_gone = 0;
-        }
-    }
-    else if (++m_gone == ((std::numeric_limits<unsigned>::max)() / 2))
-    {
-        // timeout occured, normalize the m_gone count
-        // this may occur if many calls to wait with a timeout are made and
-        // no call to notify_* is made
-        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-        assert(res == WAIT_OBJECT_0);
-        m_blocked -= m_gone;
-        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-        assert(res);
-        m_gone = 0;
-    }
-    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-    assert(res);
-
-    if (was_waiting == 1)
-    {
-        for (/**/ ; was_gone; --was_gone)
-        {
-            // better now than spurious later
-            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
-                INFINITE);
-            assert(res == WAIT_OBJECT_0);
-        }
-        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-        assert(res);
-    }
-}
-
-bool condition_impl::do_timed_wait(const xtime& xt)
-{
-    bool ret = false;
-    unsigned int res = 0;
-
-    for (;;)
-    {
-        int milliseconds;
-        to_duration(xt, milliseconds);
-
-        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
-            milliseconds);
-        assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
-        ret = (res == WAIT_OBJECT_0);
-
-        if (res == WAIT_TIMEOUT)
-        {
-            xtime cur;
-            xtime_get(&cur, TIME_UTC);
-            if (xtime_cmp(xt, cur) > 0)
-                continue;
-        }
-
-        break;
-    }
-
-    unsigned was_waiting=0;
-    unsigned was_gone=0;
-
-    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
-    assert(res == WAIT_OBJECT_0);
-    was_waiting = m_waiting;
-    was_gone = m_gone;
-    if (was_waiting != 0)
-    {
-        if (!ret) // timeout
-        {
-            if (m_blocked != 0)
-                --m_blocked;
-            else
-                ++m_gone; // count spurious wakeups
-        }
-        if (--m_waiting == 0)
-        {
-            if (m_blocked != 0)
-            {
-                res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1,
-                    0); // open m_gate
-                assert(res);
-                was_waiting = 0;
-            }
-            else if (m_gone != 0)
-                m_gone = 0;
-        }
-    }
-    else if (++m_gone == ((std::numeric_limits<unsigned>::max)() / 2))
-    {
-        // timeout occured, normalize the m_gone count
-        // this may occur if many calls to wait with a timeout are made and
-        // no call to notify_* is made
-        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-        assert(res == WAIT_OBJECT_0);
-        m_blocked -= m_gone;
-        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-        assert(res);
-        m_gone = 0;
-    }
-    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-    assert(res);
-
-    if (was_waiting == 1)
-    {
-        for (/**/ ; was_gone; --was_gone)
-        {
-            // better now than spurious later
-            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
-                INFINITE);
-            assert(res ==  WAIT_OBJECT_0);
-        }
-        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-        assert(res);
-    }
-
-    return ret;
-}
-#elif defined(BOOST_HAS_PTHREADS)
-condition_impl::condition_impl()
-{
-    int res = 0;
-    res = pthread_cond_init(&m_condition, 0);
-    if (res != 0)
-        throw thread_resource_error();
-}
-
-condition_impl::~condition_impl()
-{
-    int res = 0;
-    res = pthread_cond_destroy(&m_condition);
-    assert(res == 0);
-}
-
-void condition_impl::notify_one()
-{
-    int res = 0;
-    res = pthread_cond_signal(&m_condition);
-    assert(res == 0);
-}
-
-void condition_impl::notify_all()
-{
-    int res = 0;
-    res = pthread_cond_broadcast(&m_condition);
-    assert(res == 0);
-}
-
-void condition_impl::do_wait(pthread_mutex_t* pmutex)
-{
-    int res = 0;
-    res = pthread_cond_wait(&m_condition, pmutex);
-    assert(res == 0);
-}
-
-bool condition_impl::do_timed_wait(const xtime& xt, pthread_mutex_t* pmutex)
-{
-    timespec ts;
-    to_timespec(xt, ts);
-
-    int res = 0;
-    res = pthread_cond_timedwait(&m_condition, pmutex, &ts);
-// Test code for QNX debugging, to get information during regressions
-#ifndef NDEBUG
-    if (res == EINVAL) {
-        boost::xtime now;
-        boost::xtime_get(&now, boost::TIME_UTC);
-        std::cerr << "now: " << now.sec << " " << now.nsec << std::endl;
-        std::cerr << "time: " << time(0) << std::endl;
-        std::cerr << "xtime: " << xt.sec << " " << xt.nsec << std::endl;
-        std::cerr << "ts: " << ts.tv_sec << " " << ts.tv_nsec << std::endl;
-        std::cerr << "pmutex: " << pmutex << std::endl;
-        std::cerr << "condition: " << &m_condition << std::endl;
-        assert(res != EINVAL);
-    }
-#endif    
-    assert(res == 0 || res == ETIMEDOUT);
-
-    return res != ETIMEDOUT;
-}
-#elif defined(BOOST_HAS_MPTASKS)
-
-using threads::mac::detail::safe_enter_critical_region;
-using threads::mac::detail::safe_wait_on_semaphore;
-
-condition_impl::condition_impl()
-    : m_gone(0), m_blocked(0), m_waiting(0)
-{
-    threads::mac::detail::thread_init();
-
-    OSStatus lStatus = noErr;
-
-    lStatus = MPCreateSemaphore(1, 1, &m_gate);
-    if(lStatus == noErr)
-        lStatus = MPCreateSemaphore(ULONG_MAX, 0, &m_queue);
-
-    if(lStatus != noErr || !m_gate || !m_queue)
-    {
-        if (m_gate)
-        {
-            lStatus = MPDeleteSemaphore(m_gate);
-            assert(lStatus == noErr);
-        }
-        if (m_queue)
-        {
-            lStatus = MPDeleteSemaphore(m_queue);
-            assert(lStatus == noErr);
-        }
-
-        throw thread_resource_error();
-    }
-}
-
-condition_impl::~condition_impl()
-{
-    OSStatus lStatus = noErr;
-    lStatus = MPDeleteSemaphore(m_gate);
-    assert(lStatus == noErr);
-    lStatus = MPDeleteSemaphore(m_queue);
-    assert(lStatus == noErr);
-}
-
-void condition_impl::notify_one()
-{
-    unsigned signals = 0;
-
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-
-    if (m_waiting != 0) // the m_gate is already closed
-    {
-        if (m_blocked == 0)
-        {
-            lStatus = MPExitCriticalRegion(m_mutex);
-            assert(lStatus == noErr);
-            return;
-        }
-
-        ++m_waiting;
-        --m_blocked;
-    }
-    else
-    {
-        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-        assert(lStatus == noErr);
-        if (m_blocked > m_gone)
-        {
-            if (m_gone != 0)
-            {
-                m_blocked -= m_gone;
-                m_gone = 0;
-            }
-            signals = m_waiting = 1;
-            --m_blocked;
-        }
-        else
-        {
-            lStatus = MPSignalSemaphore(m_gate);
-            assert(lStatus == noErr);
-        }
-
-        lStatus = MPExitCriticalRegion(m_mutex);
-        assert(lStatus == noErr);
-
-        while (signals)
-        {
-            lStatus = MPSignalSemaphore(m_queue);
-            assert(lStatus == noErr);
-            --signals;
-        }
-    }
-}
-
-void condition_impl::notify_all()
-{
-    unsigned signals = 0;
-
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-
-    if (m_waiting != 0) // the m_gate is already closed
-    {
-        if (m_blocked == 0)
-        {
-            lStatus = MPExitCriticalRegion(m_mutex);
-            assert(lStatus == noErr);
-            return;
-        }
-
-        m_waiting += (signals = m_blocked);
-        m_blocked = 0;
-    }
-    else
-    {
-        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-        assert(lStatus == noErr);
-        if (m_blocked > m_gone)
-        {
-            if (m_gone != 0)
-            {
-                m_blocked -= m_gone;
-                m_gone = 0;
-            }
-            signals = m_waiting = m_blocked;
-            m_blocked = 0;
-        }
-        else
-        {
-            lStatus = MPSignalSemaphore(m_gate);
-            assert(lStatus == noErr);
-        }
-
-        lStatus = MPExitCriticalRegion(m_mutex);
-        assert(lStatus == noErr);
-
-        while (signals)
-        {
-            lStatus = MPSignalSemaphore(m_queue);
-            assert(lStatus == noErr);
-            --signals;
-        }
-    }
-}
-
-void condition_impl::enter_wait()
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-    assert(lStatus == noErr);
-    ++m_blocked;
-    lStatus = MPSignalSemaphore(m_gate);
-    assert(lStatus == noErr);
-}
-
-void condition_impl::do_wait()
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
-    assert(lStatus == noErr);
-
-    unsigned was_waiting=0;
-    unsigned was_gone=0;
-
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-    was_waiting = m_waiting;
-    was_gone = m_gone;
-    if (was_waiting != 0)
-    {
-        if (--m_waiting == 0)
-        {
-            if (m_blocked != 0)
-            {
-                lStatus = MPSignalSemaphore(m_gate); // open m_gate
-                assert(lStatus == noErr);
-                was_waiting = 0;
-            }
-            else if (m_gone != 0)
-                m_gone = 0;
-        }
-    }
-    else if (++m_gone == ((std::numeric_limits<unsigned>::max)() / 2))
-    {
-        // timeout occured, normalize the m_gone count
-        // this may occur if many calls to wait with a timeout are made and
-        // no call to notify_* is made
-        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-        assert(lStatus == noErr);
-        m_blocked -= m_gone;
-        lStatus = MPSignalSemaphore(m_gate);
-        assert(lStatus == noErr);
-        m_gone = 0;
-    }
-    lStatus = MPExitCriticalRegion(m_mutex);
-    assert(lStatus == noErr);
-
-    if (was_waiting == 1)
-    {
-        for (/**/ ; was_gone; --was_gone)
-        {
-            // better now than spurious later
-            lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
-            assert(lStatus == noErr);
-        }
-        lStatus = MPSignalSemaphore(m_gate);
-        assert(lStatus == noErr);
-    }
-}
-
-bool condition_impl::do_timed_wait(const xtime& xt)
-{
-    int milliseconds;
-    to_duration(xt, milliseconds);
-
-    OSStatus lStatus = noErr;
-    lStatus = safe_wait_on_semaphore(m_queue, milliseconds);
-    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-
-    bool ret = (lStatus == noErr);
-
-    unsigned was_waiting=0;
-    unsigned was_gone=0;
-
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-    was_waiting = m_waiting;
-    was_gone = m_gone;
-    if (was_waiting != 0)
-    {
-        if (!ret) // timeout
-        {
-            if (m_blocked != 0)
-                --m_blocked;
-            else
-                ++m_gone; // count spurious wakeups
-        }
-        if (--m_waiting == 0)
-        {
-            if (m_blocked != 0)
-            {
-                lStatus = MPSignalSemaphore(m_gate); // open m_gate
-                assert(lStatus == noErr);
-                was_waiting = 0;
-            }
-            else if (m_gone != 0)
-                m_gone = 0;
-        }
-    }
-    else if (++m_gone == ((std::numeric_limits<unsigned>::max)() / 2))
-    {
-        // timeout occured, normalize the m_gone count
-        // this may occur if many calls to wait with a timeout are made and
-        // no call to notify_* is made
-        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-        assert(lStatus == noErr);
-        m_blocked -= m_gone;
-        lStatus = MPSignalSemaphore(m_gate);
-        assert(lStatus == noErr);
-        m_gone = 0;
-    }
-    lStatus = MPExitCriticalRegion(m_mutex);
-    assert(lStatus == noErr);
-
-    if (was_waiting == 1)
-    {
-        for (/**/ ; was_gone; --was_gone)
-        {
-            // better now than spurious later
-            lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
-            assert(lStatus == noErr);
-        }
-        lStatus = MPSignalSemaphore(m_gate);
-        assert(lStatus == noErr);
-    }
-
-    return ret;
-}
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//   22 May 01  WEKEMPF Modified to use xtime for time outs.
-//    3 Jan 03  WEKEMPF Modified for DLL implementation.

src/mac/debug_prefix.hpp

@@ -1,8 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#define TARGET_CARBON    1

src/mac/delivery_man.cpp

@@ -1,66 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "delivery_man.hpp"
-
-#include "os.hpp"
-#include "execution_context.hpp"
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-delivery_man::delivery_man():
-    m_pPackage(NULL),
-    m_pSemaphore(kInvalidID),
-    m_bPackageWaiting(false)
-{
-    assert(at_st());
-
-    OSStatus lStatus = MPCreateSemaphore(1UL, 0UL, &m_pSemaphore);
-// TODO - throw on error here
-    assert(lStatus == noErr);
-}
-
-delivery_man::~delivery_man()
-{
-    assert(m_bPackageWaiting == false);
-
-    OSStatus lStatus = MPDeleteSemaphore(m_pSemaphore);
-    assert(lStatus == noErr);
-}
-
-
-void delivery_man::accept_deliveries()
-{
-    if(m_bPackageWaiting)
-    {
-        assert(m_pPackage != NULL);
-        m_pPackage->accept();
-        m_pPackage = NULL;
-        m_bPackageWaiting = false;
-
-    // signal to the thread making the call that we're done
-        OSStatus lStatus = MPSignalSemaphore(m_pSemaphore);
-        assert(lStatus == noErr);
-    }
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/delivery_man.hpp

@@ -1,84 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_DELIVERY_MAN_MJM012402_HPP
-#define BOOST_DELIVERY_MAN_MJM012402_HPP
-
-
-#include <boost/function.hpp>
-#include <boost/utility.hpp>
-
-#include <boost/thread/mutex.hpp>
-
-#include "package.hpp"
-
-#include <Multiprocessing.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class delivery_man is intended to move boost::function objects from MP tasks to
-//    other execution contexts (such as deferred task time or system task time).
-
-class delivery_man: private noncopyable
-{
-  public:
-    delivery_man();
-    ~delivery_man();
-
-  public:
-    template<class R>
-    R deliver(function<R> &rFunctor);
-
-    void accept_deliveries();
-
-  private:
-    base_package *m_pPackage;
-    mutex m_oMutex;
-    MPSemaphoreID m_pSemaphore;
-    bool m_bPackageWaiting;
-};
-
-
-template<class R>
-R delivery_man::deliver(function<R> &rFunctor)
-{
-    assert(at_mp());
-
-// lock our mutex
-    mutex::scoped_lock oLock(m_oMutex);
-
-// create a package and save it
-    package<R> oPackage(rFunctor);
-    m_pPackage = &oPackage;
-    m_bPackageWaiting = true;
-
-// wait on the semaphore
-    OSStatus lStatus = MPWaitOnSemaphore(m_pSemaphore, kDurationForever);
-    assert(lStatus == noErr);
-
-    return(oPackage.return_value());
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_DELIVERY_MAN_MJM012402_HPP

src/mac/dt_scheduler.cpp

@@ -1,93 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "dt_scheduler.hpp"
-
-#include "ot_context.hpp"
-
-
-#include <boost/thread/detail/singleton.hpp>
-
-#include <OpenTransportProtocol.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-const OTTimeout k_ulTimerTaskDelay = 1UL;
-
-
-dt_scheduler::dt_scheduler():
-    m_bReschedule(false),
-    m_uppTask(NULL),
-    m_lTask(0UL)
-{
-    using ::boost::detail::thread::singleton;
-
-    ot_context &rContext(singleton<ot_context>::instance());
-
-    m_uppTask = NewOTProcessUPP(task_entry);
-    m_lTask = OTCreateTimerTaskInContext(m_uppTask, this, rContext.get_context());
-}
-
-dt_scheduler::~dt_scheduler()
-{
-    OTDestroyTimerTask(m_lTask);
-    m_lTask = 0UL;
-    DisposeOTProcessUPP(m_uppTask);
-    m_uppTask = NULL;
-}
-
-
-void dt_scheduler::start_polling()
-{
-    m_bReschedule = true;
-    schedule_task();
-}
-
-void dt_scheduler::stop_polling()
-{
-    m_bReschedule = false;
-}
-
-
-void dt_scheduler::schedule_task()
-{
-    if(m_bReschedule)
-    {
-        OTScheduleTimerTask(m_lTask, k_ulTimerTaskDelay);
-    }
-}
-
-
-/*static*/ pascal void dt_scheduler::task_entry(void *pRefCon)
-{
-    dt_scheduler *pThis = reinterpret_cast<dt_scheduler *>(pRefCon);
-    assert(pThis != NULL);
-    pThis->task();
-}
-
-void dt_scheduler::task()
-{
-    periodic_function();
-    schedule_task();
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/dt_scheduler.hpp

@@ -1,63 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_DT_SCHEDULER_MJM012402_HPP
-#define BOOST_DT_SCHEDULER_MJM012402_HPP
-
-
-#include "periodical.hpp"
-
-#include <OpenTransport.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class dt_scheduler calls its pure-virtual periodic_function method periodically at
-//    deferred task time.  This is generally 1kHz under Mac OS 9.
-
-class dt_scheduler
-{
-  public:
-    dt_scheduler();
-    virtual ~dt_scheduler();
-
-  protected:
-    void start_polling();
-    void stop_polling();
-
-  private:
-    virtual void periodic_function() = 0;
-
-  private:
-    void schedule_task();
-    static pascal void task_entry(void *pRefCon);
-    void task();
-
-  private:
-    bool m_bReschedule;
-    OTProcessUPP m_uppTask;
-    long m_lTask;
-};
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_DT_SCHEDULER_MJM012402_HPP

src/mac/execution_context.cpp

@@ -1,60 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include <Debugging.h>
-#include <Multiprocessing.h>
-
-#include "execution_context.hpp"
-#include "init.hpp"
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-
-execution_context_t execution_context()
-{
-// make sure that MP services are available the first time through
-    static bool bIgnored = detail::thread_init();
-
-// first check if we're an MP task
-    if(MPTaskIsPreemptive(kInvalidID))
-    {
-        return(k_eExecutionContextMPTask);
-    }
-
-#if TARGET_CARBON
-// Carbon has TaskLevel
-    UInt32 ulLevel = TaskLevel();
-
-    if(ulLevel == 0UL)
-    {
-        return(k_eExecutionContextSystemTask);
-    }
-
-    if(ulLevel & kInDeferredTaskMask)
-    {
-        return(k_eExecutionContextDeferredTask);
-    }
-
-    return(k_eExecutionContextOther);
-#else
-// this can be implemented using TaskLevel if you don't mind linking against
-//    DebugLib (and therefore breaking Mac OS 8.6 support), or CurrentExecutionLevel.
-#    error execution_context unimplimented
-#endif
-}
-
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/execution_context.hpp

@@ -1,47 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_EXECUTION_CONTEXT_MJM012402_HPP
-#define BOOST_EXECUTION_CONTEXT_MJM012402_HPP
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-
-// utility functions for figuring out what context your code is executing in.
-//    Bear in mind that at_mp and in_blue are the only functions guarenteed by
-//    Apple to work.  There is simply no way of being sure that you will not get
-//    false readings about task level at interrupt time in blue.
-
-typedef enum {
-    k_eExecutionContextSystemTask,
-    k_eExecutionContextDeferredTask,
-    k_eExecutionContextMPTask,
-    k_eExecutionContextOther
-} execution_context_t;
-
-execution_context_t execution_context();
-
-inline bool at_st()
-    {    return(execution_context() == k_eExecutionContextSystemTask);    }
-
-inline bool at_mp()
-    {    return(execution_context() == k_eExecutionContextMPTask);        }
-inline bool in_blue()
-    {    return(!at_mp());                                                }
-
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-#endif // BOOST_EXECUTION_CONTEXT_MJM012402_HPP

src/mac/init.cpp

@@ -1,58 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "init.hpp"
-
-#include "remote_call_manager.hpp"
-
-
-#include <boost/thread/detail/singleton.hpp>
-
-#include <Multiprocessing.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-namespace {
-
-// force these to get called by the end of static initialization time.
-static bool g_bInitialized = (thread_init() && create_singletons());
-
-}
-
-
-bool thread_init()
-{
-    static bool bResult = MPLibraryIsLoaded();
-
-    return(bResult);
-}
-
-bool create_singletons()
-{
-    using ::boost::detail::thread::singleton;
-
-    singleton<remote_call_manager>::instance();
-
-    return(true);
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/init.hpp

@@ -1,34 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_INIT_MJM012402_HPP
-#define BOOST_INIT_MJM012402_HPP
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-bool thread_init();
-bool create_singletons();
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_INIT_MJM012402_HPP

src/mac/msl_replacements/assert.cpp

@@ -1,24 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include <cassert>
-#include <cstdio>
-
-#include <MacTypes.h>
-
-#include "remote_calls.hpp"
-
-// this function will be called when an assertion fails.  We redirect the assertion
-//    to DebugStr (MacsBug under Mac OS 1.x-9.x, Console under Mac OS X).
-void __assertion_failed(char const *pszAssertion, char const *pszFile, int nLine)
-{
-    using std::snprintf;
-    unsigned char strlDebug[sizeof(Str255) + 1];
-    char *pszDebug = reinterpret_cast<char *>(&strlDebug[1]);
-    strlDebug[0] = snprintf(pszDebug, sizeof(Str255), "assertion failed: \"%s\", %s, line %d", pszAssertion, pszFile, nLine);
-    boost::threads::mac::dt_remote_call(DebugStr, static_cast<ConstStringPtr>(strlDebug));
-}

src/mac/msl_replacements/console_io.cpp

@@ -1,128 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-//
-// includes
-//
-
-#include <abort_exit.h>
-#include <console.h>
-#include <console_io.h>
-#include <misc_io.h>
-#include <SIOUX.h>
-
-#include "remote_calls.hpp"
-
-
-//
-// using declarations
-//
-
-using std::__file_handle;
-using std::__idle_proc;
-using std::__io_error;
-using std::__no_io_error;
-using std::size_t;
-
-using boost::threads::mac::st_remote_call;
-
-
-//
-// prototypes
-//
-
-static bool check_console();
-static int do_read_console(__file_handle ulHandle, unsigned char *pBuffer, size_t *pCount, __idle_proc pfnIdleProc);
-static int do_write_console(__file_handle ulHandle, unsigned char *pBuffer, size_t *pCount, __idle_proc pfnIdleProc);
-
-
-//
-// MSL function replacements
-//
-
-// these two functions are called by cin and cout, respectively, as well as by (all?)
-//    other functions in MSL that do console I/O.  All that they do is as the remote
-//    call manager to ensure that their guts are called at system task time.
-int __read_console(__file_handle handle, unsigned char * buffer, size_t * count, __idle_proc idle_proc)
-{
-    return(st_remote_call(do_read_console, handle, buffer, count, idle_proc));
-}
-
-int __write_console(__file_handle handle, unsigned char * buffer, size_t * count, __idle_proc idle_proc)
-{
-    return(st_remote_call(do_write_console, handle, buffer, count, idle_proc));
-}
-
-
-//
-// implementations
-//
-
-static bool check_console()
-{
-    static bool s_bHaveConsole(false);
-    static bool s_bWontHaveConsole(false);
-
-    if(s_bHaveConsole)
-    {
-        return(true);
-    }
-
-    if(s_bWontHaveConsole == false)
-    {
-        __stdio_atexit();
-
-        if(InstallConsole(0) != 0)
-        {
-            s_bWontHaveConsole = true;
-            return(false);
-        }
-        __console_exit = RemoveConsole;
-        s_bHaveConsole = true;
-        return(true);
-    }
-
-    return(false);
-}
-
-
-int do_read_console(__file_handle /*ulHandle*/, unsigned char *pBuffer, size_t *pCount, __idle_proc /*pfnIdleProc*/)
-{
-    assert(pCount != NULL);
-    assert(pBuffer != NULL || *pCount == 0UL);
-
-    if(check_console() == false)
-    {
-        return(__io_error);
-    }
-    std::fflush(stdout);
-    long lCount = ReadCharsFromConsole(reinterpret_cast<char *>(pBuffer), static_cast<long>(*pCount));
-    *pCount = static_cast<size_t>(lCount);
-    if(lCount == -1L)
-    {
-        return(__io_error);
-    }
-
-    return(__no_io_error);
-}
-
-int do_write_console(__file_handle /*ulHandle*/, unsigned char *pBuffer, size_t *pCount, __idle_proc /*pfnIdleProc*/)
-{
-    if(check_console() == false)
-    {
-        return(__io_error);
-    }
-
-    long lCount = WriteCharsToConsole(reinterpret_cast<char *>(pBuffer), static_cast<long>(*pCount));
-    *pCount = static_cast<size_t>(lCount);
-    if(lCount == -1L)
-    {
-        return(__io_error);
-    }
-
-    return(__no_io_error);
-}

src/mac/msl_replacements/malloc.cpp

@@ -1,52 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-//
-// includes
-//
-
-#include <cstdlib>
-
-#include <Multiprocessing.h>
-
-
-//
-// using declarations
-//
-
-using std::size_t;
-
-
-extern "C" {
-
-//
-// prototypes
-//
-
-void *malloc(size_t ulSize);
-void free(void *pBlock);
-
-}
-
-
-//
-// MSL function replacements
-//
-
-// all allocation/deallocation currently goes through MPAllocateAligned/MPFree.  This
-//    solution is sub-optimal at best, but will have to do for now.
-void *malloc(size_t ulSize)
-{
-    static bool bIgnored = MPLibraryIsLoaded();
-    return(MPAllocateAligned(ulSize, kMPAllocateDefaultAligned, 0UL));
-}
-
-void free(void *pBlock)
-{
-    if(pBlock == NULL) return;
-    MPFree(pBlock);
-}

src/mac/msl_replacements/news_and_deletes.cpp

@@ -1,99 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-//
-// includes
-//
-
-#include <new>
-
-#include <Multiprocessing.h>
-
-
-//
-// using declarations
-//
-
-using std::size_t;
-using std::bad_alloc;
-using std::nothrow_t;
-using std::nothrow;
-
-
-//
-// local utility functions
-//
-
-// all allocation/deallocation currently goes through MPAllocateAligned/MPFree.  This
-//    solution is sub-optimal at best, but will have to do for now.
-inline static void *allocate(size_t ulSize, const nothrow_t &)
-{
-    static bool bIgnored = MPLibraryIsLoaded();
-    return(MPAllocateAligned(ulSize, kMPAllocateDefaultAligned, 0UL));
-}
-
-inline static void *allocate(size_t ulSize)
-{
-    void *pBlock = allocate(ulSize, nothrow);
-    if(pBlock == NULL)
-        throw(bad_alloc());
-    return(pBlock);
-}
-
-inline static void deallocate(void *pBlock)
-{
-    if(pBlock == NULL) return;
-    MPFree(pBlock);
-}
-
-
-//
-// global operators
-//
-
-void *operator new(size_t ulSize)
-{
-    return(allocate(ulSize));
-}
-
-void *operator new[](size_t ulSize)
-{
-    return(allocate(ulSize));
-}
-
-
-void *operator new(size_t ulSize, const nothrow_t &rNoThrow)
-{
-    return(allocate(ulSize, rNoThrow));
-}
-
-void *operator new[](size_t ulSize, const nothrow_t &rNoThrow)
-{
-    return(allocate(ulSize, rNoThrow));
-}
-
-
-void operator delete(void *pBlock)
-{
-    deallocate(pBlock);
-}
-
-void operator delete[](void *pBlock)
-{
-    deallocate(pBlock);
-}
-
-
-void operator delete(void *pBlock, const nothrow_t &)
-{
-    deallocate(pBlock);
-}
-
-void operator delete[](void *pBlock, const nothrow_t &)
-{
-    deallocate(pBlock);
-}

src/mac/msl_replacements/time.cpp

@@ -1,150 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include <cassert>
-// we include timesize.mac.h to get whether or not __TIMESIZE_DOUBLE__ is
-//  defined.  This is not safe, given that __TIMESIZE_DOUBLE__ affects MSL
-//  at MSL's compile time, not ours, so be forgiving if you have changed it
-//  since you have built MSL.
-#include <timesize.mac.h>
-#include <time.h>
-
-#include <boost/thread/detail/force_cast.hpp>
-#include <boost/thread/xtime.hpp>
-
-#include "execution_context.hpp"
-
-#include <DriverServices.h>
-
-
-extern "C"
-{
-    clock_t __get_clock();
-    time_t __get_time();
-    int __to_gm_time(time_t *pTime);
-    int __is_dst();
-}
-
-
-static inline uint64_t get_nanoseconds()
-{
-    using boost::detail::thread::force_cast;
-    return(force_cast<uint64_t>(AbsoluteToNanoseconds(UpTime())));
-}
-
-
-#ifdef __TIMESIZE_DOUBLE__
-
-// return number of microseconds since startup as a double
-clock_t __get_clock()
-{
-    static const double k_dNanosecondsPerMicrosecond(1000.0);
-
-    return(get_nanoseconds() / k_dNanosecondsPerMicrosecond);
-}
-
-#else
-
-// return number of ticks (60th of a second) since startup as a long
-clock_t __get_clock()
-{
-    static const uint64_t k_ullTicksPerSecond(60ULL);
-    static const uint64_t k_ullNanosecondsPerSecond(1000ULL * 1000ULL * 1000ULL);
-    static const uint64_t k_ullNanosecondsPerTick(k_ullNanosecondsPerSecond / k_ullTicksPerSecond);
-
-    return(get_nanoseconds() / k_ullNanosecondsPerTick);
-}
-
-#endif
-
-// return number of seconds elapsed since Jan 1, 1970
-time_t __get_time()
-{
-    boost::xtime sTime;
-    int nType = boost::xtime_get(&sTime, boost::TIME_UTC);
-    assert(nType == boost::TIME_UTC);
-    return(static_cast<time_t>(sTime.sec));
-}
-
-
-static inline MachineLocation &read_location()
-{
-    static MachineLocation s_sLocation;
-    assert(boost::threads::mac::at_st());
-    ReadLocation(&s_sLocation);
-    return(s_sLocation);
-}
-
-static inline MachineLocation &get_location()
-{
-    static MachineLocation &s_rLocation(read_location());
-    return(s_rLocation);
-}
-
-
-// force the machine location to be cached at static initlialization
-static MachineLocation &g_rIgnored(get_location());
-
-static inline long calculate_delta()
-{
-    MachineLocation &rLocation(get_location());
-
-// gmtDelta is a 24-bit, signed integer.  We need to strip out the lower 24 bits,
-//  then sign-extend what we have.
-    long lDelta = rLocation.u.gmtDelta & 0x00ffffffL;
-    if((lDelta & 0x00800000L) != 0L)
-    {
-        lDelta |= 0xFF000000;
-    }
-    return(lDelta);
-}
-
-static inline bool check_if_location_is_broken()
-{
-    MachineLocation &rLocation(get_location());
-    if(rLocation.latitude == 0 && rLocation.longitude == 0 && rLocation.u.gmtDelta == 0)
-        return(true);
-    return(false);
-}
-
-static inline bool location_is_broken()
-{
-    static bool s_bLocationIsBroken(check_if_location_is_broken());
-    return(s_bLocationIsBroken);
-}
-
-
-// translate time to GMT
-int __to_gm_time(time_t *pTime)
-{
-    if(location_is_broken())
-    {
-        return(0);
-    }
-
-    static long s_lDelta(calculate_delta());
-    *pTime -= s_lDelta;
-    return(1);
-}
-
-
-static inline bool is_daylight_savings_time()
-{
-    MachineLocation &rLocation(get_location());
-    return(rLocation.u.dlsDelta != 0);
-}
-
-// check if we're in daylight savings time
-int __is_dst()
-{
-    if(location_is_broken())
-    {
-        return(-1);
-    }
-    static bool bIsDaylightSavingsTime(is_daylight_savings_time());
-    return(static_cast<int>(bIsDaylightSavingsTime));
-}

src/mac/os.cpp

@@ -1,57 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "os.hpp"
-
-
-#include <cassert>
-
-#include <Gestalt.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace os {
-
-
-// read the OS version from Gestalt
-static inline long get_version()
-{
-    long lVersion;
-    OSErr nErr = Gestalt(gestaltSystemVersion, &lVersion);
-    assert(nErr == noErr);
-    return(lVersion);
-}
-
-
-// check if we're running under Mac OS X and cache that information
-bool x()
-{
-    static bool bX = (version() >= 0x1000);
-    return(bX);
-}
-
-
-// read the OS version and cache it
-long version()
-{
-    static long lVersion = get_version();
-    return(lVersion);
-}
-
-
-} // namespace os
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/os.hpp

@@ -1,37 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_OS_MJM012402_HPP
-#define BOOST_OS_MJM012402_HPP
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace os {
-
-
-// functions to determine the OS environment.  With namespaces, you get a cute call:
-//    mac::os::x
-
-bool x();
-long version();
-
-
-} // namespace os
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_OS_MJM012402_HPP

src/mac/ot_context.cpp

@@ -1,46 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "ot_context.hpp"
-
-#include "execution_context.hpp"
-
-
-#include <cassert>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-ot_context::ot_context()
-{
-    assert(at_st());
-
-    OSStatus lStatus = InitOpenTransportInContext(0UL, &m_pContext);
-// TODO - throw on error
-    assert(lStatus == noErr);
-}
-
-ot_context::~ot_context()
-{
-    CloseOpenTransportInContext(m_pContext);
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/ot_context.hpp

@@ -1,58 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_OT_CONTEXT_MJM012402_HPP
-#define BOOST_OT_CONTEXT_MJM012402_HPP
-
-
-#include <OpenTransport.h>
-
-#include <boost/utility.hpp>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class ot_context is intended to be used only as a singleton.  All that this class
-//    does is ask OpenTransport to create him an OTClientContextPtr, and then doles
-//    this out to anyone who wants it.  ot_context should only be instantiated at
-//    system task time.
-
-class ot_context: private noncopyable
-{
-  protected:
-    ot_context();
-    ~ot_context();
-
-  public:
-    OTClientContextPtr get_context();
-
-  private:
-    OTClientContextPtr m_pContext;
-};
-
-
-inline OTClientContextPtr ot_context::get_context()
-    {    return(m_pContext);    }
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_OT_CONTEXT_MJM012402_HPP

src/mac/package.hpp

@@ -1,76 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_PACKAGE_MJM012402_HPP
-#define BOOST_PACKAGE_MJM012402_HPP
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-class base_package: private noncopyable
-{
-  public:
-    virtual void accept() = 0;
-};
-
-template<class R>
-class package: public base_package
-{
-  public:
-    inline package(function<R> &rFunctor):
-        m_rFunctor(rFunctor)
-        {    /* no-op */                }
-    inline ~package()
-        {    /* no-op */                }
-
-    virtual void accept()
-        {    m_oR = m_rFunctor();    }
-    inline R return_value()
-        {    return(m_oR);            }
-
-  private:
-    function<R> &m_rFunctor;
-    R m_oR;
-};
-
-template<>
-class package<void>: public base_package
-{
-  public:
-    inline package(function<void> &rFunctor):
-        m_rFunctor(rFunctor)
-        {    /* no-op */                }
-    inline ~package()
-        {    /* no-op */                }
-
-    virtual void accept()
-        {    m_rFunctor();            }
-    inline void return_value()
-        {    return;                    }
-
-  private:
-    function<void> &m_rFunctor;
-};
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_PACKAGE_MJM012402_HPP

src/mac/periodical.hpp

@@ -1,97 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_PERIODICAL_MJM012402_HPP
-#define BOOST_PERIODICAL_MJM012402_HPP
-
-
-#include <boost/function.hpp>
-#include <boost/utility.hpp>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class periodical inherits from its template parameter, which should follow the
-//    pattern set by classes dt_scheduler and st_scheduler.  periodical knows how to
-//    call a boost::function, where the xx_scheduler classes only know to to call a
-//    member periodically.
-
-template<class Scheduler>
-class periodical: private noncopyable, private Scheduler
-{
-  public:
-    periodical(function<void> &rFunction);
-    ~periodical();
-
-  public:
-    void start();
-    void stop();
-
-  protected:
-    virtual void periodic_function();
-
-  private:
-    function<void> m_oFunction;
-};
-
-
-template<class Scheduler>
-periodical<Scheduler>::periodical(function<void> &rFunction):
-    m_oFunction(rFunction)
-{
-// no-op
-}
-
-template<class Scheduler>
-periodical<Scheduler>::~periodical()
-{
-    stop();
-}
-
-template<class Scheduler>
-void periodical<Scheduler>::start()
-{
-    start_polling();
-}
-
-template<class Scheduler>
-void periodical<Scheduler>::stop()
-{
-    stop_polling();
-}
-
-
-template<class Scheduler>
-inline void periodical<Scheduler>::periodic_function()
-{
-    try
-    {
-        m_oFunction();
-    }
-    catch(...)
-    {
-    }
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_PERIODICAL_MJM012402_HPP

src/mac/prefix.hpp

@@ -1,9 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#define NDEBUG
-#define TARGET_CARBON    1

src/mac/remote_call_manager.cpp

@@ -1,48 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "remote_call_manager.hpp"
-
-#include <boost/bind.hpp>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-using detail::delivery_man;
-
-
-remote_call_manager::remote_call_manager():
-    m_oDTDeliveryMan(),
-    m_oSTDeliveryMan(),
-    m_oDTFunction(bind(&delivery_man::accept_deliveries, &m_oDTDeliveryMan)),
-    m_oSTFunction(bind(&delivery_man::accept_deliveries, &m_oSTDeliveryMan)),
-    m_oDTPeriodical(m_oDTFunction),
-    m_oSTPeriodical(m_oSTFunction)
-{
-    m_oDTPeriodical.start();
-    m_oSTPeriodical.start();
-}
-
-remote_call_manager::~remote_call_manager()
-{
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/remote_call_manager.hpp

@@ -1,102 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP
-#define BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP
-
-
-#include <boost/utility.hpp>
-
-#include "delivery_man.hpp"
-#include "dt_scheduler.hpp"
-#include "periodical.hpp"
-#include "execution_context.hpp"
-#include "st_scheduler.hpp"
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class remote_call_manager is used by the remote call functions (dt_remote_call and
-//  st_remote_call) to execute functions in non-MP contexts.
-
-class remote_call_manager: private noncopyable
-{
-  protected:
-    remote_call_manager();
-    ~remote_call_manager();
-
-  public:
-    template<class R>
-    R execute_at_dt(function<R> &rFunctor);
-    template<class R>
-    R execute_at_st(function<R> &rFunctor);
-
-  private:
-    template<class R>
-    static R execute_now(function<R> &rFunctor);
-
-  private:
-    delivery_man m_oDTDeliveryMan;
-    delivery_man m_oSTDeliveryMan;
-    function<void> m_oDTFunction;
-    function<void> m_oSTFunction;
-    periodical<dt_scheduler> m_oDTPeriodical;
-    periodical<st_scheduler> m_oSTPeriodical;
-};
-
-
-template<class R>
-/*static*/ inline R remote_call_manager::execute_now(function<R> &rFunctor)
-{
-    return(rFunctor());
-}
-template<>
-/*static*/ inline void remote_call_manager::execute_now<void>(function<void> &rFunctor)
-{
-    rFunctor();
-}
-
-
-template<class R>
-inline R remote_call_manager::execute_at_dt(function<R> &rFunctor)
-{
-    if(at_mp())
-    {
-        return(m_oDTDeliveryMan.deliver(rFunctor));
-    }
-    return(execute_now(rFunctor));
-}
-
-template<class R>
-inline R remote_call_manager::execute_at_st(function<R> &rFunctor)
-{
-    if(at_mp())
-    {
-        return(m_oSTDeliveryMan.deliver(rFunctor));
-    }
-    assert(at_st());
-    return(execute_now(rFunctor));
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP

src/mac/remote_calls.hpp

@@ -1,157 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_REMOTE_CALLS_MJM012402_HPP
-#define BOOST_REMOTE_CALLS_MJM012402_HPP
-
-
-#include <boost/bind.hpp>
-
-#include "remote_call_manager.hpp"
-#include <boost/thread/detail/singleton.hpp>
-
-
-// this file contains macros to generate functions with the signatures:
-//  ReturnType st_remote_call([pascal] ReturnType (*pfnFunction)(
-//                              [Argument1Type[, Argument2Type[...]]])
-//                            [, Argument1Type oArgument1[, Argument2Type oArgument2[...]]])
-// and
-//  ReturnType dt_remote_call([pascal] ReturnType (*pfnFunction)(
-//                              [Argument1Type[, Argument2Type[...]]])
-//                            [, Argument1Type oArgument1[, Argument2Type oArgument2[...]]])
-// in other words, identical to the function pointer versions of boost::bind, but
-//  with the return type returned.  The purpose of these functions is to be able to
-//  request that a function be called at system task time or deferred task time, then
-//  sleep until it is called, and finally get back its return value.
-
-#define BOOST_REMOTE_CALL_CLASS_LIST_0
-#define BOOST_REMOTE_CALL_CLASS_LIST_1 BOOST_REMOTE_CALL_CLASS_LIST_0, class A1
-#define BOOST_REMOTE_CALL_CLASS_LIST_2 BOOST_REMOTE_CALL_CLASS_LIST_1, class A2
-#define BOOST_REMOTE_CALL_CLASS_LIST_3 BOOST_REMOTE_CALL_CLASS_LIST_2, class A3
-#define BOOST_REMOTE_CALL_CLASS_LIST_4 BOOST_REMOTE_CALL_CLASS_LIST_3, class A4
-#define BOOST_REMOTE_CALL_CLASS_LIST_5 BOOST_REMOTE_CALL_CLASS_LIST_4, class A5
-#define BOOST_REMOTE_CALL_CLASS_LIST_6 BOOST_REMOTE_CALL_CLASS_LIST_5, class A6
-#define BOOST_REMOTE_CALL_CLASS_LIST_7 BOOST_REMOTE_CALL_CLASS_LIST_6, class A7
-#define BOOST_REMOTE_CALL_CLASS_LIST_8 BOOST_REMOTE_CALL_CLASS_LIST_7, class A8
-#define BOOST_REMOTE_CALL_CLASS_LIST_9 BOOST_REMOTE_CALL_CLASS_LIST_8, class A9
-
-
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_0
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_1 BOOST_REMOTE_CALL_ARGUMENT_LIST_0  A1 oA1
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_2 BOOST_REMOTE_CALL_ARGUMENT_LIST_1, A2 oA2
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_3 BOOST_REMOTE_CALL_ARGUMENT_LIST_2, A3 oA3
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_4 BOOST_REMOTE_CALL_ARGUMENT_LIST_3, A4 oA4
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_5 BOOST_REMOTE_CALL_ARGUMENT_LIST_4, A5 oA5
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_6 BOOST_REMOTE_CALL_ARGUMENT_LIST_5, A6 oA6
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_7 BOOST_REMOTE_CALL_ARGUMENT_LIST_6, A7 oA7
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_8 BOOST_REMOTE_CALL_ARGUMENT_LIST_7, A8 oA8
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_9 BOOST_REMOTE_CALL_ARGUMENT_LIST_8, A9 oA9
-
-
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_0
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_1 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_0, oA1
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_2 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_1, oA2
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_3 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_2, oA3
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_4 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_3, oA4
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_5 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_4, oA5
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_6 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_5, oA6
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_7 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_6, oA7
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_8 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_7, oA8
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_9 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_8, oA9
-
-
-#define BOOST_REMOTE_CALL_COMMA_0
-#define BOOST_REMOTE_CALL_COMMA_1 ,
-#define BOOST_REMOTE_CALL_COMMA_2 ,
-#define BOOST_REMOTE_CALL_COMMA_3 ,
-#define BOOST_REMOTE_CALL_COMMA_4 ,
-#define BOOST_REMOTE_CALL_COMMA_5 ,
-#define BOOST_REMOTE_CALL_COMMA_6 ,
-#define BOOST_REMOTE_CALL_COMMA_7 ,
-#define BOOST_REMOTE_CALL_COMMA_8 ,
-#define BOOST_REMOTE_CALL_COMMA_9 ,
-
-
-// this is the macro that ties it all together.  From here, we generate all forms of
-//  dt_remote_call and st_remote_call.
-
-#define BOOST_REMOTE_CALL(context, stack, n)                                        \
-template<class R BOOST_REMOTE_CALL_CLASS_LIST_ ## n>                                \
-inline R context ## _remote_call(stack R (*pfnF)(                                   \
-                                      BOOST_REMOTE_CALL_ARGUMENT_LIST_ ## n)        \
-                                      BOOST_REMOTE_CALL_COMMA_ ## n                 \
-                                  BOOST_REMOTE_CALL_ARGUMENT_LIST_ ## n)            \
-{                                                                                   \
-    using ::boost::detail::thread::singleton;                                       \
-    using detail::remote_call_manager;                                              \
-    function<R> oFunc(bind(pfnF BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_ ## n));   \
-    remote_call_manager &rManager(singleton<remote_call_manager>::instance());      \
-    return(rManager.execute_at_ ## context(oFunc));                                 \
-}
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-
-BOOST_REMOTE_CALL(st, , 0)
-BOOST_REMOTE_CALL(st, , 1)
-BOOST_REMOTE_CALL(st, , 2)
-BOOST_REMOTE_CALL(st, , 3)
-BOOST_REMOTE_CALL(st, , 4)
-BOOST_REMOTE_CALL(st, , 5)
-BOOST_REMOTE_CALL(st, , 6)
-BOOST_REMOTE_CALL(st, , 7)
-BOOST_REMOTE_CALL(st, , 8)
-BOOST_REMOTE_CALL(st, , 9)
-
-BOOST_REMOTE_CALL(dt, , 0)
-BOOST_REMOTE_CALL(dt, , 1)
-BOOST_REMOTE_CALL(dt, , 2)
-BOOST_REMOTE_CALL(dt, , 3)
-BOOST_REMOTE_CALL(dt, , 4)
-BOOST_REMOTE_CALL(dt, , 5)
-BOOST_REMOTE_CALL(dt, , 6)
-BOOST_REMOTE_CALL(dt, , 7)
-BOOST_REMOTE_CALL(dt, , 8)
-BOOST_REMOTE_CALL(dt, , 9)
-
-
-BOOST_REMOTE_CALL(st, pascal, 0)
-BOOST_REMOTE_CALL(st, pascal, 1)
-BOOST_REMOTE_CALL(st, pascal, 2)
-BOOST_REMOTE_CALL(st, pascal, 3)
-BOOST_REMOTE_CALL(st, pascal, 4)
-BOOST_REMOTE_CALL(st, pascal, 5)
-BOOST_REMOTE_CALL(st, pascal, 6)
-BOOST_REMOTE_CALL(st, pascal, 7)
-BOOST_REMOTE_CALL(st, pascal, 8)
-BOOST_REMOTE_CALL(st, pascal, 9)
-
-BOOST_REMOTE_CALL(dt, pascal, 0)
-BOOST_REMOTE_CALL(dt, pascal, 1)
-BOOST_REMOTE_CALL(dt, pascal, 2)
-BOOST_REMOTE_CALL(dt, pascal, 3)
-BOOST_REMOTE_CALL(dt, pascal, 4)
-BOOST_REMOTE_CALL(dt, pascal, 5)
-BOOST_REMOTE_CALL(dt, pascal, 6)
-BOOST_REMOTE_CALL(dt, pascal, 7)
-BOOST_REMOTE_CALL(dt, pascal, 8)
-BOOST_REMOTE_CALL(dt, pascal, 9)
-
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_REMOTE_CALLS_MJM012402_HPP

src/mac/safe.cpp

@@ -1,210 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include <DriverServices.h>
-#include <Events.h>
-#include <Multiprocessing.h>
-#include <Threads.h>
-
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
-
-#include <boost/thread/detail/force_cast.hpp>
-#include <limits>
-#include "execution_context.hpp"
-
-
-using boost::detail::thread::force_cast;
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-static OSStatus safe_wait(function<OSStatus, Duration> &rFunction, Duration lDuration);
-
-
-// we call WNE to allow tasks that own the resource the blue is waiting on system
-//    task time, in case they are blocked on an ST remote call (or a memory allocation
-//    for that matter).
-static void idle()
-{
-    if(at_st())
-    {
-        EventRecord sEvent;
-        bool bEvent = WaitNextEvent(0U, &sEvent, 0UL, NULL);
-    }
-}
-
-
-OSStatus safe_wait_on_semaphore(MPSemaphoreID pSemaphoreID, Duration lDuration)
-{
-    function<OSStatus, Duration> oWaitOnSemaphore;
-    oWaitOnSemaphore = bind(MPWaitOnSemaphore, pSemaphoreID, _1);
-    return(safe_wait(oWaitOnSemaphore, lDuration));
-}
-
-
-OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Duration lDuration, MPCriticalRegionID pCriticalRegionCriticalRegionID/* = kInvalidID*/)
-{
-    if(pCriticalRegionCriticalRegionID != kInvalidID)
-    {
-        if(at_mp())
-        {
-        // enter the critical region's critical region
-            OSStatus lStatus = noErr;
-            AbsoluteTime sExpiration;
-            if(lDuration != kDurationImmediate && lDuration != kDurationForever)
-            {
-                sExpiration = AddDurationToAbsolute(lDuration, UpTime());
-            }
-            lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, lDuration);
-            assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-            if(lStatus == noErr)
-            {
-            // calculate a new duration
-                if(lDuration != kDurationImmediate && lDuration != kDurationForever)
-                {
-                // check if we have any time left
-                    AbsoluteTime sUpTime(UpTime());
-                    if(force_cast<uint64_t>(sExpiration) > force_cast<uint64_t>(sUpTime))
-                    {
-                    // reset our duration to our remaining time
-                        lDuration = AbsoluteDeltaToDuration(sExpiration, sUpTime);
-                    }
-                    else
-                    {
-                    // no time left
-                        lDuration = kDurationImmediate;
-                    }
-                }
-            // if we entered the critical region, exit it again
-                lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
-                assert(lStatus == noErr);
-            }
-            else
-            {
-            // otherwise, give up
-                return(lStatus);
-            }
-        }
-        else
-        {
-        // if we're at system task time, try to enter the critical region's critical
-        //    region until we succeed.  MP tasks will block on this until we let it go.
-            OSStatus lStatus;
-            do
-            {
-                lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, kDurationImmediate);
-            } while(lStatus == kMPTimeoutErr);
-            assert(lStatus == noErr);
-        }
-    }
-
-// try to enter the critical region
-    function<OSStatus, Duration> oEnterCriticalRegion;
-    oEnterCriticalRegion = bind(MPEnterCriticalRegion, pCriticalRegionID, _1);
-    OSStatus lStatus = safe_wait(oEnterCriticalRegion, lDuration);
-
-// if we entered the critical region's critical region to get the critical region,
-//    exit the critical region's critical region.
-    if(pCriticalRegionCriticalRegionID != kInvalidID && at_mp() == false)
-    {
-        lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
-        assert(lStatus == noErr);
-    }
-    return(lStatus);
-}
-
-OSStatus safe_wait_on_queue(MPQueueID pQueueID, void **pParam1, void **pParam2, void **pParam3, Duration lDuration)
-{
-    function<OSStatus, Duration> oWaitOnQueue;
-    oWaitOnQueue = bind(MPWaitOnQueue, pQueueID, pParam1, pParam2, pParam3, _1);
-    return(safe_wait(oWaitOnQueue, lDuration));
-}
-
-OSStatus safe_delay_until(AbsoluteTime *pWakeUpTime)
-{
-    if(execution_context() == k_eExecutionContextMPTask)
-    {
-        return(MPDelayUntil(pWakeUpTime));
-    }
-    else
-    {
-        uint64_t ullWakeUpTime = force_cast<uint64_t>(*pWakeUpTime);
-
-        while(force_cast<uint64_t>(UpTime()) < ullWakeUpTime)
-        {
-            idle();
-        }
-
-        return(noErr);
-    }
-}
-
-
-OSStatus safe_wait(function<OSStatus, Duration> &rFunction, Duration lDuration)
-{
-    if(execution_context() == k_eExecutionContextMPTask)
-    {
-        return(rFunction(lDuration));
-    }
-    else
-    {
-        uint64_t ullExpiration = 0ULL;
-
-    // get the expiration time in UpTime units
-        if(lDuration == kDurationForever)
-        {
-            ullExpiration = (::std::numeric_limits<uint64_t>::max)();
-        }
-        else if(lDuration == kDurationImmediate)
-        {
-            ullExpiration = force_cast<uint64_t>(UpTime());
-        }
-        else
-        {
-            AbsoluteTime sExpiration = AddDurationToAbsolute(lDuration, UpTime());
-            ullExpiration = force_cast<uint64_t>(sExpiration);
-        }
-
-        OSStatus lStatus;
-        bool bExpired = false;
-
-        do
-        {
-            lStatus = rFunction(kDurationImmediate);
-// mm - "if" #if 0'd out to allow task time to threads blocked on I/O
-#if 0
-            if(lStatus == kMPTimeoutErr)
-#endif
-            {
-                idle();
-            }
-            if(lDuration != kDurationForever)
-            {
-                bExpired = (force_cast<uint64_t>(UpTime()) < ullExpiration);
-            }
-        } while(lStatus == kMPTimeoutErr && bExpired == false);
-
-        return(lStatus);
-    }
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/safe.hpp

@@ -1,41 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_SAFE_MJM012402_HPP
-#define BOOST_SAFE_MJM012402_HPP
-
-
-#include <Multiprocessing.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// these functions are used to wain in an execution context-independent manor.  All of these
-//  functions are both MP- and ST-safe.
-
-OSStatus safe_wait_on_semaphore(MPSemaphoreID pSemaphoreID, Duration lDuration);
-OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Duration lDuration, MPCriticalRegionID pCriticalRegionCriticalRegionID = kInvalidID);
-OSStatus safe_wait_on_queue(MPQueueID pQueueID, void **pParam1, void **pParam2, void **pParam3, Duration lDuration);
-OSStatus safe_delay_until(AbsoluteTime *pWakeUpTime);
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-#endif // BOOST_SAFE_MJM012402_HPP

src/mac/scoped_critical_region.cpp

@@ -1,47 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "scoped_critical_region.hpp"
-
-#include "init.hpp"
-
-
-#include <cassert>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-scoped_critical_region::scoped_critical_region():
-    m_pCriticalRegionID(kInvalidID)
-{
-    static bool bIgnored = thread_init();
-    OSStatus lStatus = MPCreateCriticalRegion(&m_pCriticalRegionID);
-    if(lStatus != noErr || m_pCriticalRegionID == kInvalidID)
-        throw(thread_resource_error());
-}
-
-scoped_critical_region::~scoped_critical_region()
-{
-    OSStatus lStatus = MPDeleteCriticalRegion(m_pCriticalRegionID);
-    assert(lStatus == noErr);
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/scoped_critical_region.hpp

@@ -1,63 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP
-#define BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP
-
-
-#include <boost/thread/exceptions.hpp>
-
-#include <Multiprocessing.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class scoped_critical_region probably needs a new name.  Although the current name
-//    is accurate, it can be read to mean that a critical region is entered for the
-//    current scope.  In reality, a critical region is _created_ for the current scope.
-//    This class is intended as a replacement for MPCriticalRegionID that will
-//    automatically create and dispose of itself.
-
-class scoped_critical_region
-{
-  public:
-    scoped_critical_region();
-    ~scoped_critical_region();
-
-  public:
-    operator const MPCriticalRegionID &() const;
-    const MPCriticalRegionID &get() const;
-
-  private:
-    MPCriticalRegionID m_pCriticalRegionID;
-};
-
-
-// these are inlined for speed.
-inline scoped_critical_region::operator const MPCriticalRegionID &() const
-    {    return(m_pCriticalRegionID);    }
-inline const MPCriticalRegionID &scoped_critical_region::get() const
-    {    return(m_pCriticalRegionID);    }
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP

src/mac/st_scheduler.cpp

@@ -1,85 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "st_scheduler.hpp"
-
-#include <cassert>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-#if TARGET_CARBON
-
-st_scheduler::st_scheduler():
-    m_uppTask(NULL),
-    m_pTimer(NULL)
-{
-    m_uppTask = NewEventLoopTimerUPP(task_entry);
-// TODO - throw on error
-    assert(m_uppTask != NULL);
-}
-
-st_scheduler::~st_scheduler()
-{
-    DisposeEventLoopTimerUPP(m_uppTask);
-    m_uppTask = NULL;
-}
-
-
-void st_scheduler::start_polling()
-{
-    assert(m_pTimer == NULL);
-    OSStatus lStatus = InstallEventLoopTimer(GetMainEventLoop(),
-                                                0 * kEventDurationSecond,
-                                                kEventDurationMillisecond,
-                                                m_uppTask,
-                                                this,
-                                                &m_pTimer);
-// TODO - throw on error
-    assert(lStatus == noErr);
-}
-
-void st_scheduler::stop_polling()
-{
-    assert(m_pTimer != NULL);
-    OSStatus lStatus = RemoveEventLoopTimer(m_pTimer);
-    assert(lStatus == noErr);
-    m_pTimer = NULL;
-}
-
-
-/*static*/ pascal void st_scheduler::task_entry(EventLoopTimerRef /*pTimer*/, void *pRefCon)
-{
-    st_scheduler *pThis = reinterpret_cast<st_scheduler *>(pRefCon);
-    assert(pThis != NULL);
-    pThis->task();
-}
-
-void st_scheduler::task()
-{
-    periodic_function();
-}
-
-#else
-#    error st_scheduler unimplemented!
-#endif
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/st_scheduler.hpp

@@ -1,67 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_ST_SCHEDULER_MJM012402_HPP
-#define BOOST_ST_SCHEDULER_MJM012402_HPP
-
-
-#include <CarbonEvents.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class st_scheduler calls its pure-virtual periodic_function method periodically at
-//  system task time.  This is generally 40Hz under Mac OS 9.
-
-class st_scheduler
-{
-  public:
-    st_scheduler();
-    virtual ~st_scheduler();
-
-  protected:
-    void start_polling();
-    void stop_polling();
-
-  private:
-    virtual void periodic_function() = 0;
-
-#if TARGET_CARBON
-// use event loop timers under Carbon
-  private:
-    static pascal void task_entry(EventLoopTimerRef pTimer, void *pRefCon);
-    void task();
-
-  private:
-    EventLoopTimerUPP m_uppTask;
-    EventLoopTimerRef m_pTimer;
-#else
-// this can be implemented using OT system tasks.  This would be mostly a copy-and-
-//  paste of the dt_scheduler code, replacing DeferredTask with SystemTask and DT
-//  with ST.
-#   error st_scheduler unimplemented!
-#endif
-};
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_ST_SCHEDULER_MJM012402_HPP

src/mac/thread_cleanup.cpp

@@ -1,56 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#include "thread_cleanup.hpp"
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-namespace {
-
-TaskStorageIndex g_ulIndex(0UL);
-
-} // anonymous namespace
-
-
-void do_thread_startup()
-{
-    if(g_ulIndex == 0UL)
-    {
-        OSStatus lStatus = MPAllocateTaskStorageIndex(&g_ulIndex);
-        assert(lStatus == noErr);
-    }
-    set_thread_cleanup_task(NULL);
-}
-
-void do_thread_cleanup()
-{
-    void (*pfnTask)() = MPGetTaskValue(g_ulIndex)
-}
-
-
-void set_thread_cleanup_task(void (*pfnTask)())
-{
-    lStatus = MPSetTaskValue(g_ulIndex, reinterpret_cast<TaskStorageValue>(pfnTask));
-    assert(lStatus == noErr);
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/thread_cleanup.hpp

@@ -1,36 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// 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)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_THREAD_CLEANUP_MJM012402_HPP
-#define BOOST_THREAD_CLEANUP_MJM012402_HPP
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-void do_thread_startup();
-void do_thread_cleanup();
-
-void set_thread_cleanup_task();
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_THREAD_CLEANUP_MJM012402_HPP

src/mutex.cpp

@@ -1,561 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/xtime.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/thread/exceptions.hpp>
-#include <boost/limits.hpp>
-#include <string>
-#include <stdexcept>
-#include <cassert>
-#include "timeconv.inl"
-
-#if defined(BOOST_HAS_WINTHREADS)
-#   include <new>
-#   include <boost/thread/once.hpp>
-#   include <windows.h>
-#   include <time.h>
-#   include "mutex.inl"
-#elif defined(BOOST_HAS_PTHREADS)
-#   include <errno.h>
-#elif defined(BOOST_HAS_MPTASKS)
-#    include <MacErrors.h>
-#    include "mac/init.hpp"
-#    include "mac/safe.hpp"
-#endif
-
-namespace boost {
-
-#if defined(BOOST_HAS_WINTHREADS)
-
-mutex::mutex()
-    : m_mutex(0)
-    , m_critical_section(false)
-{
-    m_critical_section = true;
-    if (m_critical_section)
-        m_mutex = new_critical_section();
-    else
-        m_mutex = new_mutex(0);
-}
-
-mutex::~mutex()
-{
-    if (m_critical_section)
-        delete_critical_section(m_mutex);
-    else
-        delete_mutex(m_mutex);
-}
-
-void mutex::do_lock()
-{
-    if (m_critical_section)
-        wait_critical_section_infinite(m_mutex);
-    else
-        wait_mutex(m_mutex, INFINITE);
-}
-
-void mutex::do_unlock()
-{
-    if (m_critical_section)
-        release_critical_section(m_mutex);
-    else
-        release_mutex(m_mutex);
-}
-
-void mutex::do_lock(cv_state&)
-{
-    do_lock();
-}
-
-void mutex::do_unlock(cv_state&)
-{
-    do_unlock();
-}
-
-try_mutex::try_mutex()
-    : m_mutex(0)
-    , m_critical_section(false)
-{
-    m_critical_section = has_TryEnterCriticalSection();
-    if (m_critical_section)
-        m_mutex = new_critical_section();
-    else
-        m_mutex = new_mutex(0);
-}
-
-try_mutex::~try_mutex()
-{
-    if (m_critical_section)
-        delete_critical_section(m_mutex);
-    else
-        delete_mutex(m_mutex);
-}
-
-void try_mutex::do_lock()
-{
-    if (m_critical_section)
-        wait_critical_section_infinite(m_mutex);
-    else
-        wait_mutex(m_mutex, INFINITE);
-}
-
-bool try_mutex::do_trylock()
-{
-    if (m_critical_section)
-        return wait_critical_section_try(m_mutex);
-    else
-        return wait_mutex(m_mutex, 0) == WAIT_OBJECT_0;
-}
-
-void try_mutex::do_unlock()
-{
-    if (m_critical_section)
-        release_critical_section(m_mutex);
-    else
-        release_mutex(m_mutex);
-}
-
-void try_mutex::do_lock(cv_state&)
-{
-    do_lock();
-}
-
-void try_mutex::do_unlock(cv_state&)
-{
-    do_unlock();
-}
-
-timed_mutex::timed_mutex()
-    : m_mutex(0)
-{
-    m_mutex = new_mutex(0);
-}
-
-timed_mutex::~timed_mutex()
-{
-    delete_mutex(m_mutex);
-}
-
-void timed_mutex::do_lock()
-{
-    wait_mutex(m_mutex, INFINITE);
-}
-
-bool timed_mutex::do_trylock()
-{
-    return wait_mutex(m_mutex, 0) == WAIT_OBJECT_0;
-}
-
-bool timed_mutex::do_timedlock(const xtime& xt)
-{
-    for (;;)
-    {
-        int milliseconds;
-        to_duration(xt, milliseconds);
-
-        int res = wait_mutex(m_mutex, milliseconds);
-
-        if (res == WAIT_TIMEOUT)
-        {
-            boost::xtime cur;
-            boost::xtime_get(&cur, boost::TIME_UTC);
-            if (boost::xtime_cmp(xt, cur) > 0)
-                continue;
-        }
-
-        return res == WAIT_OBJECT_0;
-    }
-}
-
-void timed_mutex::do_unlock()
-{
-    release_mutex(m_mutex);
-}
-
-void timed_mutex::do_lock(cv_state&)
-{
-    do_lock();
-}
-
-void timed_mutex::do_unlock(cv_state&)
-{
-    do_unlock();
-}
-
-#elif defined(BOOST_HAS_PTHREADS)
-
-mutex::mutex()
-{
-    int res = 0;
-    res = pthread_mutex_init(&m_mutex, 0);
-    if (res != 0)
-        throw thread_resource_error();
-}
-
-mutex::~mutex()
-{
-    int res = 0;
-    res = pthread_mutex_destroy(&m_mutex);
-    assert(res == 0);
-}
-
-void mutex::do_lock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    if (res == EDEADLK) throw lock_error();
-    assert(res == 0);
-}
-
-void mutex::do_unlock()
-{
-    int res = 0;
-    res = pthread_mutex_unlock(&m_mutex);
-    if (res == EPERM) throw lock_error();
-    assert(res == 0);
-}
-
-void mutex::do_lock(cv_state&)
-{
-}
-
-void mutex::do_unlock(cv_state& state)
-{
-    state.pmutex = &m_mutex;
-}
-
-try_mutex::try_mutex()
-{
-    int res = 0;
-    res = pthread_mutex_init(&m_mutex, 0);
-    if (res != 0)
-        throw thread_resource_error();
-}
-
-try_mutex::~try_mutex()
-{
-    int res = 0;
-    res = pthread_mutex_destroy(&m_mutex);
-    assert(res == 0);
-}
-
-void try_mutex::do_lock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    if (res == EDEADLK) throw lock_error();
-    assert(res == 0);
-}
-
-bool try_mutex::do_trylock()
-{
-    int res = 0;
-    res = pthread_mutex_trylock(&m_mutex);
-    if (res == EDEADLK) throw lock_error();
-    assert(res == 0 || res == EBUSY);
-    return res == 0;
-}
-
-void try_mutex::do_unlock()
-{
-    int res = 0;
-    res = pthread_mutex_unlock(&m_mutex);
-    if (res == EPERM) throw lock_error();
-    assert(res == 0);
-}
-
-void try_mutex::do_lock(cv_state&)
-{
-}
-
-void try_mutex::do_unlock(cv_state& state)
-{
-    state.pmutex = &m_mutex;
-}
-
-timed_mutex::timed_mutex()
-    : m_locked(false)
-{
-    int res = 0;
-    res = pthread_mutex_init(&m_mutex, 0);
-    if (res != 0)
-        throw thread_resource_error();
-
-    res = pthread_cond_init(&m_condition, 0);
-    if (res != 0)
-    {
-        pthread_mutex_destroy(&m_mutex);
-        throw thread_resource_error();
-    }
-}
-
-timed_mutex::~timed_mutex()
-{
-    assert(!m_locked);
-    int res = 0;
-    res = pthread_mutex_destroy(&m_mutex);
-    assert(res == 0);
-
-    res = pthread_cond_destroy(&m_condition);
-    assert(res == 0);
-}
-
-void timed_mutex::do_lock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    while (m_locked)
-    {
-        res = pthread_cond_wait(&m_condition, &m_mutex);
-        assert(res == 0);
-    }
-
-    assert(!m_locked);
-    m_locked = true;
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-}
-
-bool timed_mutex::do_trylock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    bool ret = false;
-    if (!m_locked)
-    {
-        m_locked = true;
-        ret = true;
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-    return ret;
-}
-
-bool timed_mutex::do_timedlock(const xtime& xt)
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    timespec ts;
-    to_timespec(xt, ts);
-
-    while (m_locked)
-    {
-        res = pthread_cond_timedwait(&m_condition, &m_mutex, &ts);
-        assert(res == 0 || res == ETIMEDOUT);
-
-        if (res == ETIMEDOUT)
-            break;
-    }
-
-    bool ret = false;
-    if (!m_locked)
-    {
-        m_locked = true;
-        ret = true;
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-    return ret;
-}
-
-void timed_mutex::do_unlock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    assert(m_locked);
-    m_locked = false;
-
-    res = pthread_cond_signal(&m_condition);
-    assert(res == 0);
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-}
-
-void timed_mutex::do_lock(cv_state&)
-{
-    int res = 0;
-    while (m_locked)
-    {
-        res = pthread_cond_wait(&m_condition, &m_mutex);
-        assert(res == 0);
-    }
-
-    assert(!m_locked);
-    m_locked = true;
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-}
-
-void timed_mutex::do_unlock(cv_state& state)
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    assert(m_locked);
-    m_locked = false;
-
-    res = pthread_cond_signal(&m_condition);
-    assert(res == 0);
-
-    state.pmutex = &m_mutex;
-}
-
-#elif defined(BOOST_HAS_MPTASKS)
-
-using threads::mac::detail::safe_enter_critical_region;
-
-mutex::mutex()
-{
-}
-
-mutex::~mutex()
-{
-}
-
-void mutex::do_lock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-}
-
-void mutex::do_unlock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = MPExitCriticalRegion(m_mutex);
-    assert(lStatus == noErr);
-}
-
-void mutex::do_lock(cv_state& /*state*/)
-{
-    do_lock();
-}
-
-void mutex::do_unlock(cv_state& /*state*/)
-{
-    do_unlock();
-}
-
-try_mutex::try_mutex()
-{
-}
-
-try_mutex::~try_mutex()
-{
-}
-
-void try_mutex::do_lock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-}
-
-bool try_mutex::do_trylock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = MPEnterCriticalRegion(m_mutex, kDurationImmediate);
-    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-    return lStatus == noErr;
-}
-
-void try_mutex::do_unlock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = MPExitCriticalRegion(m_mutex);
-    assert(lStatus == noErr);
-}
-
-void try_mutex::do_lock(cv_state& /*state*/)
-{
-    do_lock();
-}
-
-void try_mutex::do_unlock(cv_state& /*state*/)
-{
-    do_unlock();
-}
-
-timed_mutex::timed_mutex()
-{
-}
-
-timed_mutex::~timed_mutex()
-{
-}
-
-void timed_mutex::do_lock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-}
-
-bool timed_mutex::do_trylock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = MPEnterCriticalRegion(m_mutex, kDurationImmediate);
-    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-    return(lStatus == noErr);
-}
-
-bool timed_mutex::do_timedlock(const xtime& xt)
-{
-    int microseconds;
-    to_microduration(xt, microseconds);
-    Duration lDuration = kDurationMicrosecond * microseconds;
-
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, lDuration, m_mutex_mutex);
-    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-
-    return(lStatus == noErr);
-}
-
-void timed_mutex::do_unlock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = MPExitCriticalRegion(m_mutex);
-    assert(lStatus == noErr);
-}
-
-void timed_mutex::do_lock(cv_state& /*state*/)
-{
-    do_lock();
-}
-
-void timed_mutex::do_unlock(cv_state& /*state*/)
-{
-    do_unlock();
-}
-
-#endif
-
-} // namespace boost
-
-// Change Log:
-//   8 Feb 01  WEKEMPF Initial version.

src/mutex.inl

@@ -1,120 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-// boostinspect:nounnamed
-
-namespace {
-
-#if defined(BOOST_HAS_WINTHREADS)
-//:PREVENT THIS FROM BEING DUPLICATED
-typedef BOOL (WINAPI* TryEnterCriticalSection_type)(LPCRITICAL_SECTION lpCriticalSection);
-TryEnterCriticalSection_type g_TryEnterCriticalSection = 0;
-boost::once_flag once_init_TryEnterCriticalSection = BOOST_ONCE_INIT;
-
-void init_TryEnterCriticalSection()
-{
-    //TryEnterCriticalSection is only available on WinNT 4.0 or later; 
-    //it is not available on Win9x.
-
-    OSVERSIONINFO version_info = {sizeof(OSVERSIONINFO)};
-    ::GetVersionEx(&version_info);
-    if (version_info.dwPlatformId == VER_PLATFORM_WIN32_NT && 
-        version_info.dwMajorVersion >= 4)
-    {
-        if (HMODULE kernel_module = GetModuleHandle(TEXT("KERNEL32.DLL")))
-            g_TryEnterCriticalSection = reinterpret_cast<TryEnterCriticalSection_type>(GetProcAddress(kernel_module, TEXT("TryEnterCriticalSection")));
-    }
-}
-
-inline bool has_TryEnterCriticalSection()
-{
-    boost::call_once(init_TryEnterCriticalSection, once_init_TryEnterCriticalSection);
-    return g_TryEnterCriticalSection != 0;
-}
-
-inline HANDLE mutex_cast(void* p)
-{
-    return reinterpret_cast<HANDLE>(p);
-}
-
-inline LPCRITICAL_SECTION critical_section_cast(void* p)
-{
-    return reinterpret_cast<LPCRITICAL_SECTION>(p);
-}
-
-inline void* new_critical_section()
-{
-    try
-    {
-        LPCRITICAL_SECTION critical_section = new CRITICAL_SECTION;
-        if (critical_section == 0) throw boost::thread_resource_error();
-        InitializeCriticalSection(critical_section);
-        return critical_section;
-    }
-    catch(...)
-    {
-        throw boost::thread_resource_error();
-    }
-}
-
-inline void* new_mutex(const char* name)
-{
-#if defined(BOOST_NO_ANSI_APIS)
-    USES_CONVERSION;
-    HANDLE mutex = CreateMutexW(0, 0, A2CW(name));
-#else
-    HANDLE mutex = CreateMutexA(0, 0, name);
-#endif
-    if (mutex == 0 || mutex == INVALID_HANDLE_VALUE) //:xxx (check for both values?)
-        throw boost::thread_resource_error();
-    return reinterpret_cast<void*>(mutex);
-}
-
-inline void delete_critical_section(void* mutex)
-{
-    DeleteCriticalSection(critical_section_cast(mutex));
-    delete critical_section_cast(mutex);
-}
-
-inline void delete_mutex(void* mutex)
-{
-    int res = 0;
-    res = CloseHandle(mutex_cast(mutex));
-    assert(res);
-}
-
-inline void wait_critical_section_infinite(void* mutex)
-{
-    EnterCriticalSection(critical_section_cast(mutex)); //:xxx Can throw an exception under low memory conditions
-}
-
-inline bool wait_critical_section_try(void* mutex)
-{
-    BOOL res = g_TryEnterCriticalSection(critical_section_cast(mutex));
-    return res != 0;
-}
-
-inline int wait_mutex(void* mutex, int time)
-{
-    unsigned int res = 0;
-    res = WaitForSingleObject(mutex_cast(mutex), time);
-//:xxx    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
-    return res;
-}
-
-inline void release_critical_section(void* mutex)
-{
-    LeaveCriticalSection(critical_section_cast(mutex));
-}
-
-inline void release_mutex(void* mutex)
-{
-    BOOL res = FALSE;
-    res = ReleaseMutex(mutex_cast(mutex));
-    assert(res);
-}
-#endif
-
-}

src/once.cpp

@@ -1,213 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/detail/workaround.hpp>
-
-#include <boost/thread/once.hpp>
-#include <cstdio>
-#include <cassert>
-
-
-#if defined(BOOST_HAS_WINTHREADS)
-#   if BOOST_WORKAROUND(__BORLANDC__,<= 0x551)
-      using std::size_t;
-#   endif
-#   include <windows.h>
-#   if defined(BOOST_NO_STRINGSTREAM)
-#       include <strstream>
-
-class unfreezer
-{
-public:
-    unfreezer(std::ostrstream& s) : m_stream(s) {}
-    ~unfreezer() { m_stream.freeze(false); }
-private:
-    std::ostrstream& m_stream;
-};
-
-#   else
-#       include <sstream>
-#   endif
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <Multiprocessing.h>
-#endif
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::sprintf; }
-#endif
-
-#if defined(BOOST_HAS_PTHREADS)
-namespace {
-pthread_key_t key;
-pthread_once_t once = PTHREAD_ONCE_INIT;
-
-typedef void (*once_callback)();
-}
-
-extern "C" {
-
-    static void key_init()
-    {
-        pthread_key_create(&key, 0);
-    }
-
-    static void do_once()
-    {
-        once_callback* cb = reinterpret_cast<once_callback*>(
-            pthread_getspecific(key));
-        (**cb)();
-    }
-
-}
-#elif defined(BOOST_HAS_MPTASKS)
-namespace {
-void *remote_call_proxy(void *pData)
-{
-    std::pair<void (*)(), boost::once_flag *> &rData(
-        *reinterpret_cast<std::pair<void (*)(), boost::once_flag *> *>(pData));
-
-    if(*rData.second == false)
-    {
-        rData.first();
-        *rData.second = true;
-    }
-
-    return(NULL);
-}
-}
-
-#elif defined(BOOST_HAS_WINTHREADS)
-namespace {
-// The signature for InterlockedCompareExchange has changed with the
-// addition of Win64 support. I can't determine any (consistent and
-// portable) way of using conditional compilation to detect this, so
-// we use these type wrappers.  Unfortunately, the various vendors
-// use different calling conventions and other signature anamolies,
-// and thus have unique types as well.  This is known to work on VC6,
-// VC7, Borland 5.5.2 and gcc 3.2.  Are there other signatures for
-// other platforms?
-inline LONG ice_wrapper(LONG (__stdcall *ice)(LONG*, LONG, LONG),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (*ice)(const_cast<LONG*>(dest), exch, cmp);
-}
-
-inline LONG ice_wrapper(LONG (__stdcall *ice)(volatile LONG*, LONG, LONG),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (*ice)(dest, exch, cmp);
-}
-
-inline LONG ice_wrapper(LPVOID (__stdcall *ice)(LPVOID*, LPVOID, LPVOID),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (LONG)(*ice)((LPVOID*)dest, (LPVOID)exch, (LPVOID)cmp);
-}
-
-// The friendly form of InterlockedCompareExchange that defers
-// according to the above function type wrappers.
-inline LONG compare_exchange(volatile LPLONG dest, LONG exch, LONG cmp)
-{
-#ifdef _WIN64
-    // Original patch from Anthony Williams.
-    // I (Roland Schwarz) am trying this for RC_1_34_0, since x64 regressions are
-    // currently not run on x64 platforms for HEAD
-    return InterlockedCompareExchange(dest, exch,cmp);
-#else    
-    return ice_wrapper(&InterlockedCompareExchange, dest, exch, cmp);
-#endif
-}
-}
-#endif
-
-namespace boost {
-
-void call_once(void (*func)(), once_flag& flag)
-{
-#if defined(BOOST_HAS_WINTHREADS)
-    if (compare_exchange(&flag, 1, 1) == 0)
-    {
-#if defined(BOOST_NO_STRINGSTREAM)
-        std::ostrstream strm;
-        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" 
-             << std::hex
-             << GetCurrentProcessId() 
-             << &flag 
-             << std::ends;
-        unfreezer unfreeze(strm);
-#   if defined (BOOST_NO_ANSI_APIS)
-        USES_CONVERSION;
-        HANDLE mutex = CreateMutexW(NULL, FALSE, A2CW(strm.str()));
-#   else
-        HANDLE mutex = CreateMutexA(NULL, FALSE, strm.str());
-#   endif
-#else
-#   if defined (BOOST_NO_ANSI_APIS)
-        std::wostringstream strm;
-        strm << L"2AC1A572DB6944B0A65C38C4140AF2F4" 
-             << std::hex
-             << GetCurrentProcessId() 
-             << &flag;
-        HANDLE mutex = CreateMutexW(NULL, FALSE, strm.str().c_str());
-#   else
-        std::ostringstream strm;
-        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" 
-             << std::hex
-             << GetCurrentProcessId() 
-             << &flag;
-        HANDLE mutex = CreateMutexA(NULL, FALSE, strm.str().c_str());
-#   endif
-#endif
-        assert(mutex != NULL);
-
-        int res = 0;
-        res = WaitForSingleObject(mutex, INFINITE);
-        assert(res == WAIT_OBJECT_0);
-
-        if (compare_exchange(&flag, 1, 1) == 0)
-        {
-            try
-            {
-                func();
-            }
-            catch (...)
-            {
-                res = ReleaseMutex(mutex);
-                assert(res);
-                res = CloseHandle(mutex);
-                assert(res);
-                throw;
-            }
-            InterlockedExchange(&flag, 1);
-        }
-
-        res = ReleaseMutex(mutex);
-        assert(res);
-        res = CloseHandle(mutex);
-        assert(res);
-    }
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_once(&once, &key_init);
-    pthread_setspecific(key, &func);
-    pthread_once(&flag, do_once);
-#elif defined(BOOST_HAS_MPTASKS)
-    if(flag == false)
-    {
-        // all we do here is make a remote call to blue, as blue is not
-        // reentrant.
-        std::pair<void (*)(), once_flag *> sData(func, &flag);
-        MPRemoteCall(remote_call_proxy, &sData, kMPOwningProcessRemoteContext);
-        assert(flag == true);
-    }
-#endif
-}
-
-}
-
-// Change Log:
-//   1 Aug 01  WEKEMPF Initial version.

src/pthread/thread.cpp

@@ -0,0 +1,499 @@
+// 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/thread.hpp>
+#include <boost/thread/xtime.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/once.hpp>
+
+#include "timeconv.inl"
+
+namespace boost
+{
+    namespace detail
+    {
+        struct thread_exit_callback_node
+        {
+            boost::detail::thread_exit_function_base* func;
+            thread_exit_callback_node* next;
+        };
+
+        namespace
+        {
+            boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
+            pthread_key_t current_thread_tls_key;
+
+            extern "C"
+            {
+                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->thread_exit_callbacks)
+                        {
+                            boost::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;
+                        }
+                    }
+                }
+            }
+    
+
+            void create_current_thread_tls_key()
+            {
+                BOOST_VERIFY(!pthread_key_create(&current_thread_tls_key,NULL));
+            }
+        }
+        
+        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"
+        {
+            void* thread_proxy(void* param)
+            {
+                boost::shared_ptr<boost::detail::thread_data_base> 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&)
+                {
+                }
+                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;
+            }
+
+        }
+    }
+
+
+    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();
+            throw thread_resource_error();
+        }
+    }
+
+    thread::~thread()
+    {
+        detach();
+    }
+
+    bool thread::operator==(const thread& other) const
+    {
+        return get_id()==other.get_id();
+    }
+
+    bool thread::operator!=(const thread& other) const
+    {
+        return !operator==(other);
+    }
+
+    boost::shared_ptr<detail::thread_data_base> thread::get_thread_info() const
+    {
+        lock_guard<mutex> l(thread_info_mutex);
+        return thread_info;
+    }
+
+    void thread::join()
+    {
+        boost::shared_ptr<detail::thread_data_base> 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();
+            }
+            
+            lock_guard<mutex> l1(thread_info_mutex);
+            if(thread_info==local_thread_info)
+            {
+                thread_info.reset();
+            }
+        }
+    }
+
+    bool thread::timed_join(system_time const& wait_until)
+    {
+        boost::shared_ptr<detail::thread_data_base> 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();
+            }
+            
+            lock_guard<mutex> l1(thread_info_mutex);
+            if(thread_info==local_thread_info)
+            {
+                thread_info.reset();
+            }
+        }
+        return true;
+    }
+
+    bool thread::joinable() const
+    {
+        return get_thread_info();
+    }
+
+
+    void thread::detach()
+    {
+        boost::shared_ptr<detail::thread_data_base> local_thread_info;
+        {
+            lock_guard<mutex> l1(thread_info_mutex);
+            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;
+            }
+        }
+    }
+
+    void thread::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 thread::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()
+    {
+        return 1;
+    }
+
+    thread::id thread::get_id() const
+    {
+        boost::shared_ptr<detail::thread_data_base> local_thread_info=get_thread_info();
+        if(local_thread_info)
+        {
+            return id(local_thread_info->thread_handle);
+        }
+        else
+        {
+            return id();
+        }
+    }
+
+    void thread::interrupt()
+    {
+        boost::shared_ptr<detail::thread_data_base> 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_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond));
+            }
+        }
+    }
+
+    bool thread::interruption_requested() const
+    {
+        boost::shared_ptr<detail::thread_data_base> 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;
+        }
+    }
+    
+
+    namespace this_thread
+    {
+        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;
+            }
+        }
+    }
+
+    thread_group::thread_group()
+    {
+    }
+
+    thread_group::~thread_group()
+    {
+        // We shouldn't have to scoped_lock here, since referencing this object
+        // from another thread while we're deleting it in the current thread is
+        // going to lead to undefined behavior any way.
+        for (std::list<thread*>::iterator it = m_threads.begin();
+             it != m_threads.end(); ++it)
+        {
+            delete (*it);
+        }
+    }
+
+    thread* thread_group::create_thread(const function0<void>& threadfunc)
+    {
+        // No scoped_lock required here since the only "shared data" that's
+        // modified here occurs inside add_thread which does scoped_lock.
+        std::auto_ptr<thread> thrd(new thread(threadfunc));
+        add_thread(thrd.get());
+        return thrd.release();
+    }
+
+    void thread_group::add_thread(thread* thrd)
+    {
+        mutex::scoped_lock scoped_lock(m_mutex);
+
+        // For now we'll simply ignore requests to add a thread object multiple
+        // times. Should we consider this an error and either throw or return an
+        // error value?
+        std::list<thread*>::iterator it = std::find(m_threads.begin(),
+                                                    m_threads.end(), thrd);
+        BOOST_ASSERT(it == m_threads.end());
+        if (it == m_threads.end())
+            m_threads.push_back(thrd);
+    }
+
+    void thread_group::remove_thread(thread* thrd)
+    {
+        mutex::scoped_lock scoped_lock(m_mutex);
+
+        // For now we'll simply ignore requests to remove a thread object that's
+        // not in the group. Should we consider this an error and either throw or
+        // return an error value?
+        std::list<thread*>::iterator it = std::find(m_threads.begin(),
+                                                    m_threads.end(), thrd);
+        BOOST_ASSERT(it != m_threads.end());
+        if (it != m_threads.end())
+            m_threads.erase(it);
+    }
+
+    void thread_group::join_all()
+    {
+        mutex::scoped_lock scoped_lock(m_mutex);
+        for (std::list<thread*>::iterator it = m_threads.begin();
+             it != m_threads.end(); ++it)
+        {
+            (*it)->join();
+        }
+    }
+
+    int thread_group::size() const
+    {
+        return m_threads.size();
+    }
+
+}

src/pthread/tss.cpp

@@ -0,0 +1,187 @@
+// Copyright (C) 2001-2003 William E. Kempf
+// Copyright (C) 2006 Roland Schwarz
+//
+//  Distributed under the 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/tss.hpp>
+#ifndef BOOST_THREAD_NO_TSS_CLEANUP
+
+#include <boost/thread/once.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/exceptions.hpp>
+#include <vector>
+#include <string>
+#include <stdexcept>
+#include <cassert>
+
+namespace {
+
+typedef std::vector<void*> tss_slots;
+typedef std::vector<boost::function1<void, void*>*> tss_data_cleanup_handlers_type;
+
+boost::once_flag tss_data_once = BOOST_ONCE_INIT;
+boost::mutex* tss_data_mutex = 0;
+tss_data_cleanup_handlers_type* tss_data_cleanup_handlers = 0;
+    pthread_key_t tss_data_native_key;
+int tss_data_use = 0;
+
+void tss_data_inc_use(boost::mutex::scoped_lock& lk)
+{
+    ++tss_data_use;
+}
+
+void tss_data_dec_use(boost::mutex::scoped_lock& lk)
+{
+    if (0 == --tss_data_use)
+    {
+        tss_data_cleanup_handlers_type::size_type i;
+        for (i = 0; i < tss_data_cleanup_handlers->size(); ++i)
+        {
+            delete (*tss_data_cleanup_handlers)[i];
+        }
+        delete tss_data_cleanup_handlers;
+        tss_data_cleanup_handlers = 0;
+        lk.unlock();
+        delete tss_data_mutex;
+        tss_data_mutex = 0;
+        pthread_key_delete(tss_data_native_key);
+    }
+}
+
+extern "C" void cleanup_slots(void* p)
+{
+    tss_slots* slots = static_cast<tss_slots*>(p);
+    boost::mutex::scoped_lock lock(*tss_data_mutex);
+    for (tss_slots::size_type i = 0; i < slots->size(); ++i)
+    {
+        (*(*tss_data_cleanup_handlers)[i])((*slots)[i]);
+        (*slots)[i] = 0;
+    }
+    tss_data_dec_use(lock);
+    delete slots;
+}
+
+void init_tss_data()
+{
+    std::auto_ptr<tss_data_cleanup_handlers_type> 
+        temp(new tss_data_cleanup_handlers_type);
+
+    std::auto_ptr<boost::mutex> temp_mutex(new boost::mutex);
+    if (temp_mutex.get() == 0)
+        throw boost::thread_resource_error();
+
+    int res = pthread_key_create(&tss_data_native_key, &cleanup_slots);
+    if (res != 0)
+        return;
+
+    // The life time of cleanup handlers and mutex is beeing
+    // managed by a reference counting technique.
+    // This avoids a memory leak by releasing the global data
+    // after last use only, since the execution order of cleanup
+    // handlers is unspecified on any platform with regards to
+    // C++ destructor ordering rules.
+    tss_data_cleanup_handlers = temp.release();
+    tss_data_mutex = temp_mutex.release();
+}
+
+
+tss_slots* get_slots(bool alloc)
+{
+    tss_slots* slots = 0;
+
+    slots = static_cast<tss_slots*>(
+        pthread_getspecific(tss_data_native_key));
+
+    if (slots == 0 && alloc)
+    {
+        std::auto_ptr<tss_slots> temp(new tss_slots);
+
+        if (pthread_setspecific(tss_data_native_key, temp.get()) != 0)
+            return 0;
+        {
+            boost::mutex::scoped_lock lock(*tss_data_mutex);
+            tss_data_inc_use(lock);
+        }
+        slots = temp.release();
+    }
+
+    return slots;
+}
+
+} // namespace
+
+namespace boost {
+
+namespace detail {
+void tss::init(boost::function1<void, void*>* pcleanup)
+{
+    boost::call_once(tss_data_once, &init_tss_data);
+    if (tss_data_cleanup_handlers == 0)
+        throw thread_resource_error();
+    boost::mutex::scoped_lock lock(*tss_data_mutex);
+    try
+    {
+        tss_data_cleanup_handlers->push_back(pcleanup);
+        m_slot = tss_data_cleanup_handlers->size() - 1;
+        tss_data_inc_use(lock);
+    }
+    catch (...)
+    {
+        throw thread_resource_error();
+    }
+}
+
+tss::~tss()
+{
+    boost::mutex::scoped_lock lock(*tss_data_mutex);
+    tss_data_dec_use(lock);
+}
+
+void* tss::get() const
+{
+    tss_slots* slots = get_slots(false);
+
+    if (!slots)
+        return 0;
+
+    if (m_slot >= slots->size())
+        return 0;
+
+    return (*slots)[m_slot];
+}
+
+void tss::set(void* value)
+{
+    tss_slots* slots = get_slots(true);
+
+    if (!slots)
+        throw boost::thread_resource_error();
+
+    if (m_slot >= slots->size())
+    {
+        try
+        {
+            slots->resize(m_slot + 1);
+        }
+        catch (...)
+        {
+            throw boost::thread_resource_error();
+        }
+    }
+
+    (*slots)[m_slot] = value;
+}
+
+void tss::cleanup(void* value)
+{
+    boost::mutex::scoped_lock lock(*tss_data_mutex);
+    (*(*tss_data_cleanup_handlers)[m_slot])(value);
+}
+
+} // namespace detail
+} // namespace boost
+
+#endif //BOOST_THREAD_NO_TSS_CLEANUP

src/thread.cpp

@@ -1,371 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/thread/thread.hpp>
-#include <boost/thread/xtime.hpp>
-#include <boost/thread/condition.hpp>
-#include <cassert>
-
-#if defined(BOOST_HAS_WINTHREADS)
-#   include <windows.h>
-#   if !defined(BOOST_NO_THREADEX)
-#      include <process.h>
-#   endif
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <DriverServices.h>
-
-#   include "init.hpp"
-#   include "safe.hpp"
-#   include <boost/thread/tss.hpp>
-#endif
-
-#include "timeconv.inl"
-
-#if defined(BOOST_HAS_WINTHREADS)
-#   include "boost/thread/detail/tss_hooks.hpp"
-#endif
-
-namespace {
-
-#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_NO_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;
-}
-
-inline unsigned _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<unsigned>(hthread);
-}
-#endif
-
-class thread_param
-{
-public:
-    thread_param(const boost::function0<void>& threadfunc)
-        : m_threadfunc(threadfunc), m_started(false)
-    {
-    }
-    void wait()
-    {
-        boost::mutex::scoped_lock scoped_lock(m_mutex);
-        while (!m_started)
-            m_condition.wait(scoped_lock);
-    }
-    void started()
-    {
-        boost::mutex::scoped_lock scoped_lock(m_mutex);
-        m_started = true;
-        m_condition.notify_one();
-    }
-
-    boost::mutex m_mutex;
-    boost::condition m_condition;
-    const boost::function0<void>& m_threadfunc;
-    bool m_started;
-};
-
-} // unnamed namespace
-
-extern "C" {
-#if defined(BOOST_HAS_WINTHREADS)
-    unsigned __stdcall thread_proxy(void* param)
-#elif defined(BOOST_HAS_PTHREADS)
-        static void* thread_proxy(void* param)
-#elif defined(BOOST_HAS_MPTASKS)
-        static OSStatus thread_proxy(void* param)
-#endif
-    {
-        //try
-        //{
-            thread_param* p = static_cast<thread_param*>(param);
-            boost::function0<void> threadfunc = p->m_threadfunc;
-            p->started();
-            threadfunc();
-#if defined(BOOST_HAS_WINTHREADS)
-            on_thread_exit();
-#endif
-        //}
-        //catch (...)
-        //{
-#if defined(BOOST_HAS_WINTHREADS)
-        //    on_thread_exit();
-#endif
-        //}
-#if defined(BOOST_HAS_MPTASKS)
-        ::boost::detail::thread_cleanup();
-#endif
-        return 0;
-    }
-
-}
-
-namespace boost {
-
-thread::thread()
-    : m_joinable(false)
-{
-#if defined(BOOST_HAS_WINTHREADS)
-    m_thread = reinterpret_cast<void*>(GetCurrentThread());
-    m_id = GetCurrentThreadId();
-#elif defined(BOOST_HAS_PTHREADS)
-    m_thread = pthread_self();
-#elif defined(BOOST_HAS_MPTASKS)
-    threads::mac::detail::thread_init();
-    threads::mac::detail::create_singletons();
-    m_pTaskID = MPCurrentTaskID();
-    m_pJoinQueueID = kInvalidID;
-#endif
-}
-
-thread::thread(const function0<void>& threadfunc)
-    : m_joinable(true)
-{
-    thread_param param(threadfunc);
-#if defined(BOOST_HAS_WINTHREADS)
-    m_thread = reinterpret_cast<void*>(_beginthreadex(0, 0, &thread_proxy,
-                                           &param, 0, &m_id));
-    if (!m_thread)
-        throw thread_resource_error();
-#elif defined(BOOST_HAS_PTHREADS)
-    int res = 0;
-    res = pthread_create(&m_thread, 0, &thread_proxy, &param);
-    if (res != 0)
-        throw thread_resource_error();
-#elif defined(BOOST_HAS_MPTASKS)
-    threads::mac::detail::thread_init();
-    threads::mac::detail::create_singletons();
-    OSStatus lStatus = noErr;
-
-    m_pJoinQueueID = kInvalidID;
-    m_pTaskID = kInvalidID;
-
-    lStatus = MPCreateQueue(&m_pJoinQueueID);
-    if (lStatus != noErr) throw thread_resource_error();
-
-    lStatus = MPCreateTask(&thread_proxy, &param, 0UL, m_pJoinQueueID, NULL,
-        NULL, 0UL, &m_pTaskID);
-    if (lStatus != noErr)
-    {
-        lStatus = MPDeleteQueue(m_pJoinQueueID);
-        assert(lStatus == noErr);
-        throw thread_resource_error();
-    }
-#endif
-    param.wait();
-}
-
-thread::~thread()
-{
-    if (m_joinable)
-    {
-#if defined(BOOST_HAS_WINTHREADS)
-        int res = 0;
-        res = CloseHandle(reinterpret_cast<HANDLE>(m_thread));
-        assert(res);
-#elif defined(BOOST_HAS_PTHREADS)
-        pthread_detach(m_thread);
-#elif defined(BOOST_HAS_MPTASKS)
-        assert(m_pJoinQueueID != kInvalidID);
-        OSStatus lStatus = MPDeleteQueue(m_pJoinQueueID);
-        assert(lStatus == noErr);
-#endif
-    }
-}
-
-bool thread::operator==(const thread& other) const
-{
-#if defined(BOOST_HAS_WINTHREADS)
-    return other.m_id == m_id;
-#elif defined(BOOST_HAS_PTHREADS)
-    return pthread_equal(m_thread, other.m_thread) != 0;
-#elif defined(BOOST_HAS_MPTASKS)
-    return other.m_pTaskID == m_pTaskID;
-#endif
-}
-
-bool thread::operator!=(const thread& other) const
-{
-    return !operator==(other);
-}
-
-void thread::join()
-{
-    assert(m_joinable); //See race condition comment below
-    int res = 0;
-#if defined(BOOST_HAS_WINTHREADS)
-    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_thread), INFINITE);
-    assert(res == WAIT_OBJECT_0);
-    res = CloseHandle(reinterpret_cast<HANDLE>(m_thread));
-    assert(res);
-#elif defined(BOOST_HAS_PTHREADS)
-    res = pthread_join(m_thread, 0);
-    assert(res == 0);
-#elif defined(BOOST_HAS_MPTASKS)
-    OSStatus lStatus = threads::mac::detail::safe_wait_on_queue(
-        m_pJoinQueueID, NULL, NULL, NULL, kDurationForever);
-    assert(lStatus == noErr);
-#endif
-    // This isn't a race condition since any race that could occur would
-    // have us in undefined behavior territory any way.
-    m_joinable = false;
-}
-
-void thread::sleep(const xtime& xt)
-{
-    for (int foo=0; foo < 5; ++foo)
-    {
-#if defined(BOOST_HAS_WINTHREADS)
-        int milliseconds;
-        to_duration(xt, milliseconds);
-        Sleep(milliseconds);
-#elif defined(BOOST_HAS_PTHREADS)
-#   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
-        timespec ts;
-        to_timespec_duration(xt, ts);
-        int res = 0;
-        res = pthread_delay_np(&ts);
-        assert(res == 0);
-#   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
-#elif defined(BOOST_HAS_MPTASKS)
-        int microseconds;
-        to_microduration(xt, microseconds);
-        Duration lMicroseconds(kDurationMicrosecond * microseconds);
-        AbsoluteTime sWakeTime(DurationToAbsolute(lMicroseconds));
-        threads::mac::detail::safe_delay_until(&sWakeTime);
-#endif
-        xtime cur;
-        xtime_get(&cur, TIME_UTC);
-        if (xtime_cmp(xt, cur) <= 0)
-            return;
-    }
-}
-
-void thread::yield()
-{
-#if defined(BOOST_HAS_WINTHREADS)
-    Sleep(0);
-#elif defined(BOOST_HAS_PTHREADS)
-#   if defined(BOOST_HAS_SCHED_YIELD)
-    int res = 0;
-    res = sched_yield();
-    assert(res == 0);
-#   elif defined(BOOST_HAS_PTHREAD_YIELD)
-    int res = 0;
-    res = pthread_yield();
-    assert(res == 0);
-#   else
-    xtime xt;
-    xtime_get(&xt, TIME_UTC);
-    sleep(xt);
-#   endif
-#elif defined(BOOST_HAS_MPTASKS)
-    MPYield();
-#endif
-}
-
-thread_group::thread_group()
-{
-}
-
-thread_group::~thread_group()
-{
-    // We shouldn't have to scoped_lock here, since referencing this object
-    // from another thread while we're deleting it in the current thread is
-    // going to lead to undefined behavior any way.
-    for (std::list<thread*>::iterator it = m_threads.begin();
-         it != m_threads.end(); ++it)
-    {
-        delete (*it);
-    }
-}
-
-thread* thread_group::create_thread(const function0<void>& threadfunc)
-{
-    // No scoped_lock required here since the only "shared data" that's
-    // modified here occurs inside add_thread which does scoped_lock.
-    std::auto_ptr<thread> thrd(new thread(threadfunc));
-    add_thread(thrd.get());
-    return thrd.release();
-}
-
-void thread_group::add_thread(thread* thrd)
-{
-    mutex::scoped_lock scoped_lock(m_mutex);
-
-    // For now we'll simply ignore requests to add a thread object multiple
-    // times. Should we consider this an error and either throw or return an
-    // error value?
-    std::list<thread*>::iterator it = std::find(m_threads.begin(),
-        m_threads.end(), thrd);
-    assert(it == m_threads.end());
-    if (it == m_threads.end())
-        m_threads.push_back(thrd);
-}
-
-void thread_group::remove_thread(thread* thrd)
-{
-    mutex::scoped_lock scoped_lock(m_mutex);
-
-    // For now we'll simply ignore requests to remove a thread object that's
-    // not in the group. Should we consider this an error and either throw or
-    // return an error value?
-    std::list<thread*>::iterator it = std::find(m_threads.begin(),
-        m_threads.end(), thrd);
-    assert(it != m_threads.end());
-    if (it != m_threads.end())
-        m_threads.erase(it);
-}
-
-void thread_group::join_all()
-{
-    mutex::scoped_lock scoped_lock(m_mutex);
-    for (std::list<thread*>::iterator it = m_threads.begin();
-         it != m_threads.end(); ++it)
-    {
-        (*it)->join();
-    }
-}
-
-int thread_group::size()
-{
-        return m_threads.size();
-}
-
-} // namespace boost

src/tss_null.cpp

@@ -1,11 +1,12 @@
 // (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(_MSC_VER)
+#if defined(BOOST_HAS_WINTHREADS) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST)) && (!defined(_MSC_VER) || defined(UNDER_CE))
 
     /*
     This file is a "null" implementation of tss cleanup; it's

src/win32/exceptions.cpp

@@ -0,0 +1,124 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/exceptions.hpp>
+#include <cstring>
+#include <string>
+
+namespace boost {
+
+thread_exception::thread_exception()
+    : m_sys_err(0)
+{
+}
+
+thread_exception::thread_exception(int sys_err_code)
+    : m_sys_err(sys_err_code)
+{
+}
+
+thread_exception::~thread_exception() throw()
+{
+}
+
+int thread_exception::native_error() const
+{
+    return m_sys_err; 
+}
+
+lock_error::lock_error()
+{
+}
+
+lock_error::lock_error(int sys_err_code)
+    : thread_exception(sys_err_code)
+{
+}
+
+lock_error::~lock_error() throw()
+{
+}
+
+const char* lock_error::what() const throw()
+{
+    return "boost::lock_error";
+}
+
+thread_resource_error::thread_resource_error()
+{
+}
+
+thread_resource_error::thread_resource_error(int sys_err_code)
+    : thread_exception(sys_err_code)
+{
+}
+
+thread_resource_error::~thread_resource_error() throw()
+{
+}
+
+const char* thread_resource_error::what() const throw()
+{
+    return "boost::thread_resource_error";
+}
+
+unsupported_thread_option::unsupported_thread_option()
+{
+}
+
+unsupported_thread_option::unsupported_thread_option(int sys_err_code)
+    : thread_exception(sys_err_code)
+{
+}
+
+unsupported_thread_option::~unsupported_thread_option() throw()
+{
+}
+
+const char* unsupported_thread_option::what() const throw()
+{
+    return "boost::unsupported_thread_option";
+}
+
+invalid_thread_argument::invalid_thread_argument()
+{
+}
+
+invalid_thread_argument::invalid_thread_argument(int sys_err_code)
+    : thread_exception(sys_err_code)
+{
+}
+
+invalid_thread_argument::~invalid_thread_argument() throw()
+{
+}
+
+const char* invalid_thread_argument::what() const throw()
+{
+    return "boost::invalid_thread_argument";
+}
+
+thread_permission_error::thread_permission_error()
+{
+}
+
+thread_permission_error::thread_permission_error(int sys_err_code)
+    : thread_exception(sys_err_code)
+{
+}
+
+thread_permission_error::~thread_permission_error() throw()
+{
+}
+
+const char* thread_permission_error::what() const throw()
+{
+    return "boost::thread_permission_error";
+}
+
+} // namespace boost

src/win32/thread.cpp

@@ -0,0 +1,498 @@
+// Distributed under the 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
+
+#include <boost/thread/thread.hpp>
+#include <algorithm>
+#include <windows.h>
+#ifndef UNDER_CE
+#include <process.h>
+#endif
+#include <stdio.h>
+#include <boost/thread/once.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+    namespace
+    {
+#if defined(_MSC_VER) && !defined(UNDER_CE)
+        __declspec(thread) detail::thread_data_base* current_thread_data=0;
+        detail::thread_data_base* get_current_thread_data()
+        {
+            return current_thread_data;
+        }
+        void set_current_thread_data(detail::thread_data_base* new_data)
+        {
+            current_thread_data=new_data;
+        }
+#elif defined(__BORLANDC__)
+        detail::thread_data_base* __thread current_thread_data=0;
+        detail::thread_data_base* get_current_thread_data()
+        {
+            return current_thread_data;
+        }
+        void set_current_thread_data(detail::thread_data_base* new_data)
+        {
+            current_thread_data=new_data;
+        }
+#else
+
+        boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
+        DWORD current_thread_tls_key=0;
+
+        void create_current_thread_tls_key()
+        {
+            current_thread_tls_key=TlsAlloc();
+            BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);
+        }
+
+        detail::thread_data_base* get_current_thread_data()
+        {
+            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
+            return (detail::thread_data_base*)TlsGetValue(current_thread_tls_key);
+        }
+
+        void set_current_thread_data(detail::thread_data_base* new_data)
+        {
+            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
+            BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
+        }
+#endif
+
+#ifdef BOOST_NO_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
+
+    }
+
+    void thread::yield()
+    {
+        this_thread::yield();
+    }
+    
+    void thread::sleep(const system_time& target)
+    {
+        system_time const now(get_system_time());
+        
+        if(target<=now)
+        {
+            this_thread::yield();
+        }
+        else
+        {
+            this_thread::sleep(target-now);
+        }
+    }
+
+    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_)
+            {}
+        };
+
+    }
+
+    namespace
+    {
+        void run_thread_exit_callbacks()
+        {
+            boost::intrusive_ptr<detail::thread_data_base> current_thread_data(get_current_thread_data(),false);
+            if(current_thread_data)
+            {
+                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);
+                }
+            }
+            set_current_thread_data(0);
+        }
+        
+    }
+    
+
+    unsigned __stdcall thread::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&)
+        {
+        }
+        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)
+        {
+            throw 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(boost::intrusive_ptr<detail::thread_data_base> data):
+        thread_info(data)
+    {}
+
+    namespace
+    {
+        struct externally_launched_thread:
+            detail::thread_data_base
+        {
+            externally_launched_thread()
+            {
+                ++count;
+                interruption_enabled=false;
+                thread_handle=detail::win32::duplicate_handle(detail::win32::GetCurrentThread());
+            }
+            
+            void run()
+            {}
+        };
+    }
+
+    thread thread::self()
+    {
+        if(!get_current_thread_data())
+        {
+            externally_launched_thread* me=detail::heap_new<externally_launched_thread>();
+            set_current_thread_data(me);
+        }
+        return thread(boost::intrusive_ptr<detail::thread_data_base>(get_current_thread_data()));
+    }
+    
+    thread::~thread()
+    {
+        detach();
+    }
+    
+    thread::thread(boost::move_t<thread> x)
+    {
+        {
+            boost::mutex::scoped_lock l(x->thread_info_mutex);
+            thread_info=x->thread_info;
+        }
+        x->release_handle();
+    }
+    
+    thread& thread::operator=(boost::move_t<thread> x)
+    {
+        thread new_thread(x);
+        swap(new_thread);
+        return *this;
+    }
+        
+    thread::operator boost::move_t<thread>()
+    {
+        return move();
+    }
+
+    boost::move_t<thread> thread::move()
+    {
+        boost::move_t<thread> x(*this);
+        return x;
+    }
+
+    void thread::swap(thread& x)
+    {
+        thread_info.swap(x.thread_info);
+    }
+
+    thread::id thread::get_id() const
+    {
+        boost::intrusive_ptr<detail::thread_data_base> local_thread_info=get_thread_info();
+        return local_thread_info?thread::id(local_thread_info->id):thread::id();
+    }
+
+    thread::interruption_handle thread::get_interruption_handle() const
+    {
+        boost::intrusive_ptr<detail::thread_data_base> local_thread_info=get_thread_info();
+        return local_thread_info?thread::interruption_handle(local_thread_info->interruption_handle.duplicate()):thread::interruption_handle();
+    }
+    
+    bool thread::joinable() const
+    {
+        return get_thread_info();
+    }
+
+    void thread::join()
+    {
+        boost::intrusive_ptr<detail::thread_data_base> local_thread_info=get_thread_info();
+        if(local_thread_info)
+        {
+            this_thread::interruptible_wait(local_thread_info->thread_handle,detail::win32::infinite);
+            release_handle();
+        }
+    }
+
+    bool thread::timed_join(boost::system_time const& wait_until)
+    {
+        boost::intrusive_ptr<detail::thread_data_base> 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()
+    {
+        boost::mutex::scoped_lock l1(thread_info_mutex);
+        thread_info=0;
+    }
+    
+    void thread::interrupt()
+    {
+        boost::intrusive_ptr<detail::thread_data_base> local_thread_info=get_thread_info();
+        if(local_thread_info)
+        {
+            detail::win32::SetEvent(local_thread_info->interruption_handle);
+        }
+    }
+    
+    bool thread::interruption_requested() const
+    {
+        boost::intrusive_ptr<detail::thread_data_base> 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()
+    {
+        boost::intrusive_ptr<detail::thread_data_base> local_thread_info=get_thread_info();
+        return local_thread_info?(detail::win32::handle)local_thread_info->thread_handle:detail::win32::invalid_handle_value;
+    }
+
+    boost::intrusive_ptr<detail::thread_data_base> thread::get_thread_info() const
+    {
+        boost::mutex::scoped_lock l(thread_info_mutex);
+        return thread_info;
+    }
+
+    namespace this_thread
+    {
+        thread::interruption_handle get_interruption_handle()
+        {
+            return get_current_thread_data()?thread::interruption_handle(get_current_thread_data()->interruption_handle.duplicate()):thread::interruption_handle();
+        }
+
+        bool interruptible_wait(detail::win32::handle handle_to_wait_for,unsigned long milliseconds)
+        {
+            detail::win32::handle handles[2]={0};
+            unsigned handle_count=0;
+            unsigned interruption_index=~0U;
+            if(handle_to_wait_for!=detail::win32::invalid_handle_value)
+            {
+                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;
+            }
+        
+            if(handle_count)
+            {
+                unsigned long const notified_index=detail::win32::WaitForMultipleObjects(handle_count,handles,false,milliseconds);
+                if((handle_to_wait_for!=detail::win32::invalid_handle_value) && !notified_index)
+                {
+                    return true;
+                }
+                else if(notified_index==interruption_index)
+                {
+                    detail::win32::ResetEvent(get_current_thread_data()->interruption_handle);
+                    throw thread_interrupted();
+                }
+            }
+            else
+            {
+                detail::win32::Sleep(milliseconds);
+            }
+            return false;
+        }
+
+        thread::id get_id()
+        {
+            return thread::id(detail::win32::GetCurrentThreadId());
+        }
+
+        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
+    {
+        void NTAPI thread_exit_func_callback(HINSTANCE, DWORD, PVOID);
+        typedef void (NTAPI* tls_callback)(HINSTANCE, DWORD, PVOID);
+        
+#ifdef _MSC_VER
+        extern "C"
+        {
+            extern DWORD _tls_used; //the tls directory (located in .rdata segment)
+            extern tls_callback __xl_a[], __xl_z[];    //tls initializers */
+        }
+        
+#if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
+#   pragma data_seg(push, old_seg)
+#endif
+        
+#pragma data_seg(".CRT$XLB")
+        tls_callback p_thread_callback = thread_exit_func_callback;
+#pragma data_seg()
+        
+#if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
+#   pragma data_seg(pop, old_seg)
+#endif
+#endif
+
+        void NTAPI thread_exit_func_callback(HINSTANCE h, DWORD dwReason, PVOID pv)
+        {
+            if((dwReason==DLL_THREAD_DETACH) || (dwReason==DLL_PROCESS_DETACH))
+            {
+                run_thread_exit_callbacks();
+            }
+        }
+    }
+
+    namespace detail
+    {
+        void add_thread_exit_function(thread_exit_function_base* func)
+        {
+            thread_exit_callback_node* const new_node=
+                heap_new<thread_exit_callback_node>(func,
+                                                    get_current_thread_data()->thread_exit_callbacks);
+            get_current_thread_data()->thread_exit_callbacks=new_node;
+        }
+    }
+}
+

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.cpp

@@ -1,5 +1,7 @@
 // Copyright (C) 2001-2003 William E. Kempf
 // Copyright (C) 2006 Roland Schwarz
+// Copyright (C) 2007 Anthony Williams
+// Copyright (C) 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)
@@ -17,9 +19,10 @@
 #include <stdexcept>
 #include <cassert>
 
-#if defined(BOOST_HAS_WINTHREADS)
-#   include <windows.h>
-#   include <boost/thread/detail/tss_hooks.hpp>
+#include <windows.h>
+#include <boost/thread/detail/tss_hooks.hpp>
+#if defined(UNDER_CE) && !defined(TLS_OUT_OF_INDEXES)
+#    define TLS_OUT_OF_INDEXES 0xFFFFFFFF
 #endif
 
 namespace {
@@ -30,13 +33,7 @@ typedef std::vector<boost::function1<void, void*>*> tss_data_cleanup_handlers_ty
 boost::once_flag tss_data_once = BOOST_ONCE_INIT;
 boost::mutex* tss_data_mutex = 0;
 tss_data_cleanup_handlers_type* tss_data_cleanup_handlers = 0;
-#if defined(BOOST_HAS_WINTHREADS)
-    DWORD tss_data_native_key;
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_key_t tss_data_native_key;
-#elif defined(BOOST_HAS_MPTASKS)
-    TaskStorageIndex tss_data_native_key;
-#endif
+    DWORD tss_data_native_key=TLS_OUT_OF_INDEXES;
 int tss_data_use = 0;
 
 void tss_data_inc_use(boost::mutex::scoped_lock& lk)
@@ -58,14 +55,8 @@ void tss_data_dec_use(boost::mutex::scoped_lock& lk)
         lk.unlock();
         delete tss_data_mutex;
         tss_data_mutex = 0;
-#if defined(BOOST_HAS_WINTHREADS)
         TlsFree(tss_data_native_key);
-#elif defined(BOOST_HAS_PTHREADS)
-        pthread_key_delete(tss_data_native_key);
-#elif defined(BOOST_HAS_MPTASKS)
-        // Don't know what to put here.
-        // But MPTASKS isn't currently maintained anyways...
-#endif
+        tss_data_native_key=TLS_OUT_OF_INDEXES;
     }
 }
 
@@ -78,6 +69,7 @@ extern "C" void cleanup_slots(void* p)
         (*(*tss_data_cleanup_handlers)[i])((*slots)[i]);
         (*slots)[i] = 0;
     }
+    TlsSetValue(tss_data_native_key,0);
     tss_data_dec_use(lock);
     delete slots;
 }
@@ -91,23 +83,13 @@ void init_tss_data()
     if (temp_mutex.get() == 0)
         throw boost::thread_resource_error();
 
-#if defined(BOOST_HAS_WINTHREADS)
     //Force the cleanup implementation library to be linked in
     tss_cleanup_implemented();
 
     //Allocate tls slot
     tss_data_native_key = TlsAlloc();
-    if (tss_data_native_key == 0xFFFFFFFF)
+    if (tss_data_native_key == TLS_OUT_OF_INDEXES)
         return;
-#elif defined(BOOST_HAS_PTHREADS)
-    int res = pthread_key_create(&tss_data_native_key, &cleanup_slots);
-    if (res != 0)
-        return;
-#elif defined(BOOST_HAS_MPTASKS)
-    OSStatus status = MPAllocateTaskStorageIndex(&tss_data_native_key);
-    if (status != noErr)
-        return;
-#endif
 
     // The life time of cleanup handlers and mutex is beeing
     // managed by a reference counting technique.
@@ -119,7 +101,6 @@ void init_tss_data()
     tss_data_mutex = temp_mutex.release();
 }
 
-#if defined(BOOST_HAS_WINTHREADS)
 tss_slots* get_slots(bool alloc);
 
 void __cdecl tss_thread_exit()
@@ -128,39 +109,22 @@ void __cdecl tss_thread_exit()
     if (slots)
         cleanup_slots(slots);
 }
-#endif
 
 tss_slots* get_slots(bool alloc)
 {
     tss_slots* slots = 0;
 
-#if defined(BOOST_HAS_WINTHREADS)
     slots = static_cast<tss_slots*>(
         TlsGetValue(tss_data_native_key));
-#elif defined(BOOST_HAS_PTHREADS)
-    slots = static_cast<tss_slots*>(
-        pthread_getspecific(tss_data_native_key));
-#elif defined(BOOST_HAS_MPTASKS)
-    slots = static_cast<tss_slots*>(
-        MPGetTaskStorageValue(tss_data_native_key));
-#endif
 
     if (slots == 0 && alloc)
     {
         std::auto_ptr<tss_slots> temp(new tss_slots);
 
-#if defined(BOOST_HAS_WINTHREADS)
         if (at_thread_exit(&tss_thread_exit) == -1)
             return 0;
         if (!TlsSetValue(tss_data_native_key, temp.get()))
             return 0;
-#elif defined(BOOST_HAS_PTHREADS)
-        if (pthread_setspecific(tss_data_native_key, temp.get()) != 0)
-            return 0;
-#elif defined(BOOST_HAS_MPTASKS)
-        if (MPSetTaskStorageValue(tss_data_native_key, temp.get()) != noErr)
-            return 0;
-#endif
         {
             boost::mutex::scoped_lock lock(*tss_data_mutex);
             tss_data_inc_use(lock);
@@ -178,7 +142,7 @@ namespace boost {
 namespace detail {
 void tss::init(boost::function1<void, void*>* pcleanup)
 {
-    boost::call_once(&init_tss_data, tss_data_once);
+    boost::call_once(tss_data_once, &init_tss_data);
     if (tss_data_cleanup_handlers == 0)
         throw thread_resource_error();
     boost::mutex::scoped_lock lock(*tss_data_mutex);

src/win32/tss_hooks.cpp

@@ -1,5 +1,7 @@
 // Copyright (C) 2004 Michael Glassford
 // Copyright (C) 2006 Roland Schwarz
+// Copyright (C) 2007 Anthony Williams
+// Copyright (C) 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)
@@ -19,12 +21,16 @@
     #define WIN32_LEAN_AND_MEAN
     #include <windows.h>
 
+#   if defined(UNDER_CE) && !defined(TLS_OUT_OF_INDEXES)
+#       define TLS_OUT_OF_INDEXES 0xFFFFFFFF
+#   endif
+
     namespace
     {
         class CScopedCSLock
         {
         public:
-            CScopedCSLock(LPCRITICAL_SECTION cs) : cs(cs), lk(true) {
+            CScopedCSLock(LPCRITICAL_SECTION cs) : lk(true), cs(cs) {
                 ::EnterCriticalSection(cs);
             }
             ~CScopedCSLock() {
@@ -74,7 +80,7 @@
         thread_exit_handler exit_handler
         )
     {
-        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        boost::call_once(once_init_threadmon_mutex, init_threadmon_mutex);
         //boost::mutex::scoped_lock lock(*threadmon_mutex);
         CScopedCSLock lock(&threadmon_mutex);
 
@@ -141,7 +147,7 @@
 
     extern "C" BOOST_THREAD_DECL void on_process_enter(void)
     {
-        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        boost::call_once(once_init_threadmon_mutex, init_threadmon_mutex);
 //        boost::mutex::scoped_lock lock(*threadmon_mutex);
         CScopedCSLock lock(&threadmon_mutex);
 
@@ -150,7 +156,7 @@
 
     extern "C" BOOST_THREAD_DECL void on_process_exit(void)
     {
-        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        boost::call_once(once_init_threadmon_mutex, init_threadmon_mutex);
 //        boost::mutex::scoped_lock lock(*threadmon_mutex);
         CScopedCSLock lock(&threadmon_mutex);
 
@@ -173,7 +179,7 @@
 
     extern "C" BOOST_THREAD_DECL void on_thread_exit(void)
     {
-        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        boost::call_once(once_init_threadmon_mutex, init_threadmon_mutex);
 //        boost::mutex::scoped_lock lock(*threadmon_mutex);
         CScopedCSLock lock(&threadmon_mutex);
 

src/win32/tss_pe.cpp

@@ -1,11 +1,13 @@
 // (C) Copyright Aaron W. LaFramboise, Roland Schwarz, Michael Glassford 2004.
+// (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) && defined(_MSC_VER)
+#if defined(BOOST_THREAD_BUILD_LIB) && defined(_MSC_VER) && !defined(UNDER_CE)
 
     #include <boost/thread/detail/tss_hooks.hpp>
 

src/xtime.cpp

@@ -1,158 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/thread/detail/config.hpp>
-
-#if defined(BOOST_HAS_FTIME)
-#   define __STDC_CONSTANT_MACROS
-#endif
-
-#include <boost/thread/xtime.hpp>
-
-#if defined(BOOST_HAS_FTIME)
-#   include <windows.h>
-#   include <boost/cstdint.hpp>
-#elif defined(BOOST_HAS_GETTIMEOFDAY)
-#   include <sys/time.h>
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <DriverServices.h>
-#   include <boost/thread/detail/force_cast.hpp>
-#endif
-
-#include <cassert>
-
-namespace boost {
-
-#ifdef BOOST_HAS_MPTASKS
-
-namespace detail
-{
-
-using thread::force_cast;
-
-struct startup_time_info
-{
-    startup_time_info()
-    {
-        // 1970 Jan 1 at 00:00:00
-        static const DateTimeRec k_sUNIXBase = {1970, 1, 1, 0, 0, 0, 0};
-        static unsigned long s_ulUNIXBaseSeconds = 0UL;
-
-        if(s_ulUNIXBaseSeconds == 0UL)
-        {
-            // calculate the number of seconds between the Mac OS base and the
-            // UNIX base the first time we enter this constructor.
-            DateToSeconds(&k_sUNIXBase, &s_ulUNIXBaseSeconds);
-        }
-
-        unsigned long ulSeconds;
-
-        // get the time in UpTime units twice, with the time in seconds in the
-        // middle.
-        uint64_t ullFirstUpTime = force_cast<uint64_t>(UpTime());
-        GetDateTime(&ulSeconds);
-        uint64_t ullSecondUpTime = force_cast<uint64_t>(UpTime());
-
-        // calculate the midpoint of the two UpTimes, and save that.
-        uint64_t ullAverageUpTime = (ullFirstUpTime + ullSecondUpTime) / 2ULL;
-        m_sStartupAbsoluteTime = force_cast<AbsoluteTime>(ullAverageUpTime);
-
-        // save the number of seconds, recentered at the UNIX base.
-        m_ulStartupSeconds = ulSeconds - s_ulUNIXBaseSeconds;
-    }
-
-    AbsoluteTime m_sStartupAbsoluteTime;
-    UInt32 m_ulStartupSeconds;
-};
-
-static startup_time_info g_sStartupTimeInfo;
-
-} // namespace detail
-
-#endif
-
-
-int xtime_get(struct xtime* xtp, int clock_type)
-{
-    if (clock_type == TIME_UTC)
-    {
-#if defined(BOOST_HAS_FTIME)
-        FILETIME ft;
-#   if defined(BOOST_NO_GETSYSTEMTIMEASFILETIME)
-        {
-            SYSTEMTIME st;
-            GetSystemTime(&st);
-            SystemTimeToFileTime(&st,&ft);
-        }
-#   else
-        GetSystemTimeAsFileTime(&ft);
-#   endif
-        static const boost::uint64_t TIMESPEC_TO_FILETIME_OFFSET =
-            UINT64_C(116444736000000000);
-        
-        const boost::uint64_t ft64 =
-            (static_cast<boost::uint64_t>(ft.dwHighDateTime) << 32)
-            + ft.dwLowDateTime;
-
-        xtp->sec = static_cast<xtime::xtime_sec_t>(
-            (ft64 - TIMESPEC_TO_FILETIME_OFFSET) / 10000000
-        );
-
-        xtp->nsec = static_cast<xtime::xtime_nsec_t>(
-            ((ft64 - TIMESPEC_TO_FILETIME_OFFSET) % 10000000) * 100
-        );
-
-        return clock_type;
-#elif defined(BOOST_HAS_GETTIMEOFDAY)
-        struct timeval tv;
-#       ifndef NDEBUG
-        int res =
-#endif            
-        gettimeofday(&tv, 0);
-        assert(0 == res);
-        assert(tv.tv_sec >= 0);
-        assert(tv.tv_usec >= 0);
-        xtp->sec = tv.tv_sec;
-        xtp->nsec = tv.tv_usec * 1000;
-        return clock_type;
-#elif defined(BOOST_HAS_CLOCK_GETTIME)
-        timespec ts;
-#       ifndef NDEBUG
-        int res =
-#       endif            
-        clock_gettime(CLOCK_REALTIME, &ts);
-        assert(0 == res);
-        xtp->sec = ts.tv_sec;
-        xtp->nsec = ts.tv_nsec;
-        return clock_type;
-#elif defined(BOOST_HAS_MPTASKS)
-        using detail::thread::force_cast;
-        // the Mac OS does not have an MP-safe way of getting the date/time,
-        // so we use a delta from the startup time.  We _could_ defer this
-        // and use something that is interrupt-safe, but this would be _SLOW_,
-        // and we need speed here.
-        const uint64_t k_ullNanosecondsPerSecond(1000ULL * 1000ULL * 1000ULL);
-        AbsoluteTime sUpTime(UpTime());
-        uint64_t ullNanoseconds(
-            force_cast<uint64_t>(
-                AbsoluteDeltaToNanoseconds(sUpTime,
-                    detail::g_sStartupTimeInfo.m_sStartupAbsoluteTime)));
-        uint64_t ullSeconds = (ullNanoseconds / k_ullNanosecondsPerSecond);
-        ullNanoseconds -= (ullSeconds * k_ullNanosecondsPerSecond);
-        xtp->sec = detail::g_sStartupTimeInfo.m_ulStartupSeconds + ullSeconds;
-        xtp->nsec = ullNanoseconds;
-        return clock_type;
-#else
-#   error "xtime_get implementation undefined"
-#endif
-    }
-    return 0;
-}
-
-} // namespace boost
-
-// Change Log:
-//   8 Feb 01  WEKEMPF Initial version.

test/Jamfile.v2

@@ -40,6 +40,7 @@ rule thread-run ( sources )
           [ thread-run test_once.cpp ]
           [ thread-run test_xtime.cpp ]
           [ thread-run test_barrier.cpp ]		   
-#          [ thread-run test_read_write_mutex.cpp ]
+          [ thread-run test_shared_mutex.cpp ]
+          [ thread-run test_lock_concept.cpp ]
     ;
 }

test/test_condition.cpp

@@ -103,7 +103,7 @@ void do_test_condition_notify_one()
 
 void test_condition_notify_one()
 {
-    timed_test(&do_test_condition_notify_one, 2, execution_monitor::use_mutex);
+    timed_test(&do_test_condition_notify_one, 100, execution_monitor::use_mutex);
 }
 
 void do_test_condition_notify_all()
@@ -131,7 +131,7 @@ void test_condition_notify_all()
     // 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_notify_all, 3);
+    timed_test(&do_test_condition_notify_all, 100);
 }
 
 void do_test_condition_waits()
@@ -189,6 +189,24 @@ void test_condition_waits()
     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 =
@@ -197,6 +215,7 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
     test->add(BOOST_TEST_CASE(&test_condition_notify_one));
     test->add(BOOST_TEST_CASE(&test_condition_notify_all));
     test->add(BOOST_TEST_CASE(&test_condition_waits));
+    test->add(BOOST_TEST_CASE(&test_condition_wait_is_a_interruption_point));
 
     return test;
 }

test/test_lock_concept.cpp

@@ -0,0 +1,173 @@
+// (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/test/unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/recursive_mutex.hpp>
+
+template<typename Mutex,typename Lock>
+struct test_initially_locked
+{
+    void operator()() const
+    {
+        Mutex m;
+        Lock lock(m);
+        
+        BOOST_CHECK(lock);
+        BOOST_CHECK(lock.owns_lock());
+    }
+};
+
+template<typename Mutex,typename Lock>
+struct test_initially_unlocked_with_defer_lock_parameter
+{
+    void operator()() const
+    {
+        Mutex m;
+        Lock lock(m,boost::defer_lock);
+        
+        BOOST_CHECK(!lock);
+        BOOST_CHECK(!lock.owns_lock());
+    }
+};
+
+template<typename Mutex,typename Lock>
+struct test_initially_locked_with_adopt_lock_parameter
+{
+    void operator()() const
+    {
+        Mutex m;
+        m.lock();
+        Lock lock(m,boost::adopt_lock);
+        
+        BOOST_CHECK(lock);
+        BOOST_CHECK(lock.owns_lock());
+    }
+};
+
+
+template<typename Mutex,typename Lock>
+struct test_unlocked_after_unlock_called
+{
+    void operator()() const
+    {
+        Mutex m;
+        Lock lock(m);
+        lock.unlock();
+        BOOST_CHECK(!lock);
+        BOOST_CHECK(!lock.owns_lock());
+    }
+};
+
+template<typename Mutex,typename Lock>
+struct test_locked_after_lock_called
+{
+    void operator()() const
+    {
+        Mutex m;
+        Lock lock(m,boost::defer_lock);
+        lock.lock();
+        BOOST_CHECK(lock);
+        BOOST_CHECK(lock.owns_lock());
+    }
+};
+
+template<typename Mutex,typename Lock>
+struct test_locked_after_try_lock_called
+{
+    void operator()() const
+    {
+        Mutex m;
+        Lock lock(m,boost::defer_lock);
+        lock.try_lock();
+        BOOST_CHECK(lock);
+        BOOST_CHECK(lock.owns_lock());
+    }
+};
+
+template<typename Mutex,typename Lock>
+struct test_throws_if_lock_called_when_already_locked
+{
+    void operator()() const
+    {
+        Mutex m;
+        Lock lock(m);
+        
+        BOOST_CHECK_THROW( lock.lock(), boost::lock_error );
+    }
+};
+
+template<typename Mutex,typename Lock>
+struct test_throws_if_try_lock_called_when_already_locked
+{
+    void operator()() const
+    {
+        Mutex m;
+        Lock lock(m);
+        
+        BOOST_CHECK_THROW( lock.try_lock(), boost::lock_error );
+    }
+};
+
+template<typename Mutex,typename Lock>
+struct test_throws_if_unlock_called_when_already_unlocked
+{
+    void operator()() const
+    {
+        Mutex m;
+        Lock lock(m);
+        lock.unlock();
+        
+        BOOST_CHECK_THROW( lock.unlock(), boost::lock_error );
+    }
+};
+
+BOOST_TEST_CASE_TEMPLATE_FUNCTION(test_scoped_lock_concept,Mutex)
+{
+    typedef typename Mutex::scoped_lock Lock;
+    
+    test_initially_locked<Mutex,Lock>()();
+    test_initially_unlocked_with_defer_lock_parameter<Mutex,Lock>()();
+    test_initially_locked_with_adopt_lock_parameter<Mutex,Lock>()();
+    test_unlocked_after_unlock_called<Mutex,Lock>()();
+    test_locked_after_lock_called<Mutex,Lock>()();
+    test_throws_if_lock_called_when_already_locked<Mutex,Lock>()();
+    test_throws_if_unlock_called_when_already_unlocked<Mutex,Lock>()();
+}
+
+BOOST_TEST_CASE_TEMPLATE_FUNCTION(test_scoped_try_lock_concept,Mutex)
+{
+    typedef typename Mutex::scoped_try_lock Lock;
+    
+    test_initially_locked<Mutex,Lock>()();
+    test_initially_unlocked_with_defer_lock_parameter<Mutex,Lock>()();
+    test_initially_locked_with_adopt_lock_parameter<Mutex,Lock>()();
+    test_unlocked_after_unlock_called<Mutex,Lock>()();
+    test_locked_after_lock_called<Mutex,Lock>()();
+    test_locked_after_try_lock_called<Mutex,Lock>()();
+    test_throws_if_lock_called_when_already_locked<Mutex,Lock>()();
+    test_throws_if_try_lock_called_when_already_locked<Mutex,Lock>()();
+    test_throws_if_unlock_called_when_already_unlocked<Mutex,Lock>()();
+}
+
+boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Threads: lock concept test suite");
+
+    typedef boost::mpl::vector<boost::mutex,boost::try_mutex,boost::timed_mutex,
+        boost::recursive_mutex,boost::recursive_try_mutex,boost::recursive_timed_mutex> mutex_types;
+    
+    test->add(BOOST_TEST_CASE_TEMPLATE(test_scoped_lock_concept,mutex_types));
+
+    typedef boost::mpl::vector<boost::try_mutex,boost::timed_mutex,
+        boost::recursive_try_mutex,boost::recursive_timed_mutex> try_mutex_types;
+
+    test->add(BOOST_TEST_CASE_TEMPLATE(test_scoped_try_lock_concept,try_mutex_types));
+
+    return test;
+}

test/test_mutex.cpp

@@ -8,7 +8,7 @@
 
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/recursive_mutex.hpp>
-#include <boost/thread/xtime.hpp>
+#include <boost/thread/thread_time.hpp>
 #include <boost/thread/condition.hpp>
 
 #include <boost/test/unit_test.hpp>
@@ -29,7 +29,7 @@ struct test_lock
 
         // Test the lock's constructors.
         {
-            lock_type lock(mutex, false);
+            lock_type lock(mutex, boost::defer_lock);
             BOOST_CHECK(!lock);
         }
         lock_type lock(mutex);
@@ -69,10 +69,10 @@ struct test_trylock
             BOOST_CHECK(lock ? true : false);
         }
         {
-            try_lock_type lock(mutex, false);
+            try_lock_type lock(mutex, boost::defer_lock);
             BOOST_CHECK(!lock);
         }
-        try_lock_type lock(mutex, true);
+        try_lock_type lock(mutex);
         BOOST_CHECK(lock ? true : false);
 
         // Construct and initialize an xtime for a fast time out.
@@ -110,16 +110,16 @@ struct test_timedlock
         // Test the lock's constructors.
         {
             // Construct and initialize an xtime for a fast time out.
-            boost::xtime xt = delay(0, 100);
+            boost::system_time xt = boost::get_system_time()+boost::posix_time::milliseconds(100);
 
             timed_lock_type lock(mutex, xt);
             BOOST_CHECK(lock ? true : false);
         }
         {
-            timed_lock_type lock(mutex, false);
+            timed_lock_type lock(mutex, boost::defer_lock);
             BOOST_CHECK(!lock);
         }
-        timed_lock_type lock(mutex, true);
+        timed_lock_type lock(mutex);
         BOOST_CHECK(lock ? true : false);
 
         // Construct and initialize an xtime for a fast time out.
@@ -139,8 +139,8 @@ struct test_timedlock
         BOOST_CHECK(lock ? true : false);
         lock.unlock();
         BOOST_CHECK(!lock);
-        xt = delay(0, 100);
-        BOOST_CHECK(lock.timed_lock(xt));
+        boost::system_time target = boost::get_system_time()+boost::posix_time::milliseconds(100);
+        BOOST_CHECK(lock.timed_lock(target));
         BOOST_CHECK(lock ? true : false);
     }
 };

test/test_once.cpp

@@ -1,52 +1,160 @@
-// 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/once.hpp>
-#include <boost/thread/thread.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/test/unit_test.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/once.hpp>
 
-#include <libs/thread/test/util.inl>
+boost::once_flag flag=BOOST_ONCE_INIT;
+int var_to_init=0;
+boost::mutex m;
 
-int once_value = 0;
-boost::once_flag once = BOOST_ONCE_INIT;
-
-void init_once_value()
+void initialize_variable()
 {
-    once_value++;
+    // ensure that if multiple threads get in here, they are serialized, so we can see the effect
+    boost::mutex::scoped_lock lock(m);
+    ++var_to_init;
 }
 
-void test_once_thread()
+void call_once_thread()
 {
-    boost::call_once(init_once_value, once);
+    unsigned const loop_count=100;
+    int my_once_value=0;
+    for(unsigned i=0;i<loop_count;++i)
+    {
+        boost::call_once(flag, initialize_variable);
+        my_once_value=var_to_init;
+        if(my_once_value!=1)
+        {
+            break;
+        }
+    }
+    boost::mutex::scoped_lock lock(m);
+    BOOST_CHECK_EQUAL(my_once_value, 1);
 }
 
-void do_test_once()
+void test_call_once()
 {
-    const int NUMTHREADS=5;
-    boost::thread_group threads;
-    for (int i=0; i<NUMTHREADS; ++i)
-        threads.create_thread(&test_once_thread);
-    threads.join_all();
-    BOOST_CHECK_EQUAL(once_value, 1);
+    unsigned const num_threads=20;
+    boost::thread_group group;
+    
+    for(unsigned i=0;i<num_threads;++i)
+    {
+        group.create_thread(&call_once_thread);
+    }
+    group.join_all();
+    BOOST_CHECK_EQUAL(var_to_init,1);
 }
 
-void test_once()
+int var_to_init_with_functor=0;
+
+struct increment_value
 {
-    timed_test(&do_test_once, 2);
+    int* value;
+    explicit increment_value(int* value_):
+        value(value_)
+    {}
+    
+    void operator()() const
+    {
+        boost::mutex::scoped_lock lock(m);
+        ++(*value);
+    }
+};
+
+void call_once_with_functor()
+{
+    unsigned const loop_count=100;
+    int my_once_value=0;
+    static boost::once_flag functor_flag=BOOST_ONCE_INIT;
+    for(unsigned i=0;i<loop_count;++i)
+    {
+        boost::call_once(functor_flag, increment_value(&var_to_init_with_functor));
+        my_once_value=var_to_init_with_functor;
+        if(my_once_value!=1)
+        {
+            break;
+        }
+    }
+    boost::mutex::scoped_lock lock(m);
+    BOOST_CHECK_EQUAL(my_once_value, 1);
 }
 
+void test_call_once_arbitrary_functor()
+{
+    unsigned const num_threads=20;
+    boost::thread_group group;
+
+    for(unsigned i=0;i<num_threads;++i)
+    {
+        group.create_thread(&call_once_with_functor);
+    }
+    group.join_all();
+    BOOST_CHECK_EQUAL(var_to_init_with_functor,1);
+}
+
+
+struct throw_before_third_pass
+{
+    struct my_exception
+    {};
+
+    static unsigned pass_counter;
+    
+    void operator()() const
+    {
+        boost::mutex::scoped_lock lock(m);
+        ++pass_counter;
+        if(pass_counter<3)
+        {
+            throw my_exception();
+        }
+    }
+};
+
+unsigned throw_before_third_pass::pass_counter=0;
+unsigned exception_counter=0;
+
+void call_once_with_exception()
+{
+    static boost::once_flag functor_flag=BOOST_ONCE_INIT;
+    try
+    {
+        boost::call_once(functor_flag, throw_before_third_pass());
+    }
+    catch(throw_before_third_pass::my_exception)
+    {
+        boost::mutex::scoped_lock lock(m);
+        ++exception_counter;
+    }
+}
+
+void test_call_once_retried_on_exception()
+{
+    unsigned const num_threads=20;
+    boost::thread_group group;
+
+    for(unsigned i=0;i<num_threads;++i)
+    {
+        group.create_thread(&call_once_with_exception);
+    }
+    group.join_all();
+    BOOST_CHECK_EQUAL(throw_before_third_pass::pass_counter,3u);
+    BOOST_CHECK_EQUAL(exception_counter,2u);
+}
+
+
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
     boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: once test suite");
+        BOOST_TEST_SUITE("Boost.Threads: call_once test suite");
 
-    test->add(BOOST_TEST_CASE(test_once));
+    test->add(BOOST_TEST_CASE(test_call_once));
+    test->add(BOOST_TEST_CASE(test_call_once_arbitrary_functor));
+    test->add(BOOST_TEST_CASE(test_call_once_retried_on_exception));
 
     return test;
 }

test/test_shared_mutex.cpp

@@ -0,0 +1,524 @@
+// (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/test/unit_test.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/xtime.hpp>
+#include "util.inl"
+#include <iostream>
+#include <boost/date_time/posix_time/posix_time_io.hpp>
+
+#define CHECK_LOCKED_VALUE_EQUAL(mutex_name,value,expected_value)    \
+    {                                                                \
+        boost::mutex::scoped_lock lock(mutex_name);                  \
+        BOOST_CHECK_EQUAL(value,expected_value);                     \
+    }
+
+
+namespace
+{
+    template<typename lock_type>
+    class locking_thread
+    {
+        boost::shared_mutex& rw_mutex;
+        unsigned& unblocked_count;
+        unsigned& simultaneous_running_count;
+        unsigned& max_simultaneous_running;
+        boost::mutex& unblocked_count_mutex;
+        boost::condition_variable& unblocked_condition;
+        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;
+            }
+        }
+    };
+    
+}
+
+
+void test_multiple_readers()
+{
+    unsigned const number_of_threads=100;
+    
+    boost::thread_group pool;
+
+    boost::shared_mutex rw_mutex;
+    unsigned unblocked_count=0;
+    unsigned simultaneous_running_count=0;
+    unsigned max_simultaneous_running=0;
+    boost::mutex unblocked_count_mutex;
+    boost::condition_variable unblocked_condition;
+    boost::mutex finish_mutex;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+    
+    for(unsigned i=0;i<number_of_threads;++i)
+    {
+        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                    finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    }
+
+    {
+        boost::mutex::scoped_lock lk(unblocked_count_mutex);
+        while(unblocked_count<number_of_threads)
+        {
+            unblocked_condition.wait(lk);
+        }
+    }
+
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,number_of_threads);
+
+    finish_lock.unlock();
+
+    pool.join_all();
+
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,number_of_threads);
+}
+
+void test_only_one_writer_permitted()
+{
+    unsigned const number_of_threads=100;
+    
+    boost::thread_group pool;
+
+    boost::shared_mutex rw_mutex;
+    unsigned unblocked_count=0;
+    unsigned simultaneous_running_count=0;
+    unsigned max_simultaneous_running=0;
+    boost::mutex unblocked_count_mutex;
+    boost::condition_variable unblocked_condition;
+    boost::mutex finish_mutex;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+    
+    for(unsigned i=0;i<number_of_threads;++i)
+    {
+        pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                    finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    }
+
+    boost::thread::sleep(delay(2));
+
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,1U);
+
+    finish_lock.unlock();
+
+    pool.join_all();
+
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,number_of_threads);
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,1u);
+}
+
+void test_reader_blocks_writer()
+{
+    boost::thread_group pool;
+
+    boost::shared_mutex rw_mutex;
+    unsigned unblocked_count=0;
+    unsigned simultaneous_running_count=0;
+    unsigned max_simultaneous_running=0;
+    boost::mutex unblocked_count_mutex;
+    boost::condition_variable unblocked_condition;
+    boost::mutex finish_mutex;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+    
+    pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    {
+        boost::mutex::scoped_lock lk(unblocked_count_mutex);
+        while(unblocked_count<1)
+        {
+            unblocked_condition.wait(lk);
+        }
+    }
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,1U);
+    pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    boost::thread::sleep(delay(1));
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,1U);
+
+    finish_lock.unlock();
+
+    pool.join_all();
+
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,2U);
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,1u);
+}
+
+void test_unlocking_writer_unblocks_all_readers()
+{
+    boost::thread_group pool;
+
+    boost::shared_mutex rw_mutex;
+    boost::unique_lock<boost::shared_mutex>  write_lock(rw_mutex);
+    unsigned unblocked_count=0;
+    unsigned simultaneous_running_count=0;
+    unsigned max_simultaneous_running=0;
+    boost::mutex unblocked_count_mutex;
+    boost::condition_variable unblocked_condition;
+    boost::mutex finish_mutex;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+
+    unsigned const reader_count=100;
+
+    for(unsigned i=0;i<reader_count;++i)
+    {
+        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                    finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    }
+    boost::thread::sleep(delay(1));
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,0U);
+
+    write_lock.unlock();
+    
+    {
+        boost::mutex::scoped_lock lk(unblocked_count_mutex);
+        while(unblocked_count<reader_count)
+        {
+            unblocked_condition.wait(lk);
+        }
+    }
+
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count);
+
+    finish_lock.unlock();
+    pool.join_all();
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,reader_count);
+}
+
+void test_unlocking_last_reader_only_unblocks_one_writer()
+{
+    boost::thread_group pool;
+
+    boost::shared_mutex rw_mutex;
+    unsigned unblocked_count=0;
+    unsigned simultaneous_running_readers=0;
+    unsigned max_simultaneous_readers=0;
+    unsigned simultaneous_running_writers=0;
+    unsigned max_simultaneous_writers=0;
+    boost::mutex unblocked_count_mutex;
+    boost::condition_variable unblocked_condition;
+    boost::mutex finish_reading_mutex;
+    boost::mutex::scoped_lock finish_reading_lock(finish_reading_mutex);
+    boost::mutex finish_writing_mutex;
+    boost::mutex::scoped_lock finish_writing_lock(finish_writing_mutex);
+
+    unsigned const reader_count=100;
+    unsigned const writer_count=100;
+
+    for(unsigned i=0;i<reader_count;++i)
+    {
+        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                    finish_reading_mutex,simultaneous_running_readers,max_simultaneous_readers));
+    }
+    boost::thread::sleep(delay(1));
+    for(unsigned i=0;i<writer_count;++i)
+    {
+        pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                    finish_writing_mutex,simultaneous_running_writers,max_simultaneous_writers));
+    }
+    {
+        boost::mutex::scoped_lock lk(unblocked_count_mutex);
+        while(unblocked_count<reader_count)
+        {
+            unblocked_condition.wait(lk);
+        }
+    }
+    boost::thread::sleep(delay(1));
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count);
+
+    finish_reading_lock.unlock();
+
+    {
+        boost::mutex::scoped_lock lk(unblocked_count_mutex);
+        while(unblocked_count<(reader_count+1))
+        {
+            unblocked_condition.wait(lk);
+        }
+    }
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count+1);
+
+    finish_writing_lock.unlock();
+    pool.join_all();
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count+writer_count);
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_readers,reader_count);
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_writers,1u);
+}
+
+void test_only_one_upgrade_lock_permitted()
+{
+    unsigned const number_of_threads=100;
+    
+    boost::thread_group pool;
+
+    boost::shared_mutex rw_mutex;
+    unsigned unblocked_count=0;
+    unsigned simultaneous_running_count=0;
+    unsigned max_simultaneous_running=0;
+    boost::mutex unblocked_count_mutex;
+    boost::condition_variable unblocked_condition;
+    boost::mutex finish_mutex;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+    
+    for(unsigned i=0;i<number_of_threads;++i)
+    {
+        pool.create_thread(locking_thread<boost::upgrade_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                     finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    }
+
+    boost::thread::sleep(delay(1));
+
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,1U);
+
+    finish_lock.unlock();
+
+    pool.join_all();
+
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,number_of_threads);
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,1u);
+}
+
+void test_can_lock_upgrade_if_currently_locked_shared()
+{
+    boost::thread_group pool;
+
+    boost::shared_mutex rw_mutex;
+    unsigned unblocked_count=0;
+    unsigned simultaneous_running_count=0;
+    unsigned max_simultaneous_running=0;
+    boost::mutex unblocked_count_mutex;
+    boost::condition_variable unblocked_condition;
+    boost::mutex finish_mutex;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+
+    unsigned const reader_count=100;
+
+    for(unsigned i=0;i<reader_count;++i)
+    {
+        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                    finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    }
+    boost::thread::sleep(delay(1));
+    pool.create_thread(locking_thread<boost::upgrade_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
+                                                                                 finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    {
+        boost::mutex::scoped_lock lk(unblocked_count_mutex);
+        while(unblocked_count<(reader_count+1))
+        {
+            unblocked_condition.wait(lk);
+        }
+    }
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count+1);
+
+    finish_lock.unlock();
+    pool.join_all();
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count+1);
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,reader_count+1);
+}
+
+namespace
+{
+    class simple_writing_thread
+    {
+        boost::shared_mutex& rwm;
+        boost::mutex& finish_mutex;
+        boost::mutex& unblocked_mutex;
+        unsigned& unblocked_count;
+        
+    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);
+        }
+    };
+}
+
+void test_if_other_thread_has_write_lock_try_lock_shared_returns_false()
+{
+
+    boost::shared_mutex rw_mutex;
+    boost::mutex finish_mutex;
+    boost::mutex unblocked_mutex;
+    unsigned unblocked_count=0;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+    boost::thread writer(simple_writing_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
+    boost::thread::sleep(delay(1));
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
+
+    bool const try_succeeded=rw_mutex.try_lock_shared();
+    BOOST_CHECK(!try_succeeded);
+    if(try_succeeded)
+    {
+        rw_mutex.unlock_shared();
+    }
+
+    finish_lock.unlock();
+    writer.join();
+}
+
+void test_if_no_thread_has_lock_try_lock_shared_returns_true()
+{
+    boost::shared_mutex rw_mutex;
+    bool const try_succeeded=rw_mutex.try_lock_shared();
+    BOOST_CHECK(try_succeeded);
+    if(try_succeeded)
+    {
+        rw_mutex.unlock_shared();
+    }
+}
+
+namespace
+{
+    class simple_reading_thread
+    {
+        boost::shared_mutex& rwm;
+        boost::mutex& finish_mutex;
+        boost::mutex& unblocked_mutex;
+        unsigned& unblocked_count;
+        
+    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);
+        }
+    };
+}
+
+void test_if_other_thread_has_shared_lock_try_lock_shared_returns_true()
+{
+
+    boost::shared_mutex rw_mutex;
+    boost::mutex finish_mutex;
+    boost::mutex unblocked_mutex;
+    unsigned unblocked_count=0;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+    boost::thread writer(simple_reading_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
+    boost::thread::sleep(delay(1));
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
+
+    bool const try_succeeded=rw_mutex.try_lock_shared();
+    BOOST_CHECK(try_succeeded);
+    if(try_succeeded)
+    {
+        rw_mutex.unlock_shared();
+    }
+
+    finish_lock.unlock();
+    writer.join();
+}
+
+void test_timed_lock_shared_times_out_if_write_lock_held()
+{
+    boost::shared_mutex rw_mutex;
+    boost::mutex finish_mutex;
+    boost::mutex unblocked_mutex;
+    unsigned unblocked_count=0;
+    boost::mutex::scoped_lock finish_lock(finish_mutex);
+    boost::thread writer(simple_writing_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
+    boost::thread::sleep(delay(1));
+    CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
+
+    boost::system_time const start=boost::get_system_time();
+    boost::system_time const timeout=start+boost::posix_time::milliseconds(2000);
+    bool const timed_lock_succeeded=rw_mutex.timed_lock_shared(timeout);
+    BOOST_CHECK(in_range(boost::get_xtime(timeout),1));
+    BOOST_CHECK(!timed_lock_succeeded);
+    if(timed_lock_succeeded)
+    {
+        rw_mutex.unlock_shared();
+    }
+
+    finish_lock.unlock();
+    writer.join();
+}
+
+
+boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Threads: shared_mutex test suite");
+
+    test->add(BOOST_TEST_CASE(&test_multiple_readers));
+    test->add(BOOST_TEST_CASE(&test_only_one_writer_permitted));
+    test->add(BOOST_TEST_CASE(&test_reader_blocks_writer));
+    test->add(BOOST_TEST_CASE(&test_unlocking_writer_unblocks_all_readers));
+    test->add(BOOST_TEST_CASE(&test_unlocking_last_reader_only_unblocks_one_writer));
+    test->add(BOOST_TEST_CASE(&test_only_one_upgrade_lock_permitted));
+    test->add(BOOST_TEST_CASE(&test_can_lock_upgrade_if_currently_locked_shared));
+    test->add(BOOST_TEST_CASE(&test_if_other_thread_has_write_lock_try_lock_shared_returns_false));
+    test->add(BOOST_TEST_CASE(&test_if_no_thread_has_lock_try_lock_shared_returns_true));
+    test->add(BOOST_TEST_CASE(&test_if_other_thread_has_shared_lock_try_lock_shared_returns_true));
+    test->add(BOOST_TEST_CASE(&test_timed_lock_shared_times_out_if_write_lock_held));
+
+    return test;
+}

test/test_thread.cpp

@@ -8,6 +8,9 @@
 
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+#include <boost/utility.hpp>
 
 #include <boost/test/unit_test.hpp>
 
@@ -21,12 +24,16 @@ void simple_thread()
     test_value = 999;
 }
 
-void comparison_thread(boost::thread* parent)
+void comparison_thread(boost::thread::id parent)
 {
-    boost::thread thrd;
-    BOOST_CHECK(thrd != *parent);
-    boost::thread thrd2;
-    BOOST_CHECK(thrd == thrd2);
+    boost::thread::id const my_id=boost::this_thread::get_id();
+    
+    BOOST_CHECK(my_id != parent);
+    boost::thread::id const my_id2=boost::this_thread::get_id();
+    BOOST_CHECK(my_id == my_id2);
+
+    boost::thread::id const no_thread_id=boost::thread::id();
+    BOOST_CHECK(my_id != no_thread_id);
 }
 
 void test_sleep()
@@ -52,18 +59,146 @@ void test_creation()
     timed_test(&do_test_creation, 1);
 }
 
-void do_test_comparison()
+void do_test_id_comparison()
 {
-    boost::thread self;
-    boost::thread thrd(bind(&comparison_thread, &self));
+    boost::thread::id const self=boost::this_thread::get_id();
+    boost::thread thrd(boost::bind(&comparison_thread, self));
     thrd.join();
 }
 
-void test_comparison()
+void test_id_comparison()
 {
-    timed_test(&do_test_comparison, 1);
+    timed_test(&do_test_id_comparison, 1);
 }
 
+void interruption_point_thread(boost::mutex* m,bool* failed)
+{
+    boost::mutex::scoped_lock lk(*m);
+    boost::this_thread::interruption_point();
+    *failed=true;
+}
+
+void do_test_thread_interrupts_at_interruption_point()
+{
+    boost::mutex m;
+    bool failed=false;
+    boost::mutex::scoped_lock lk(m);
+    boost::thread thrd(boost::bind(&interruption_point_thread,&m,&failed));
+    thrd.interrupt();
+    lk.unlock();
+    thrd.join();
+    BOOST_CHECK(!failed);
+}
+
+void test_thread_interrupts_at_interruption_point()
+{
+    timed_test(&do_test_thread_interrupts_at_interruption_point, 1);
+}
+
+void disabled_interruption_point_thread(boost::mutex* m,bool* failed)
+{
+    boost::mutex::scoped_lock lk(*m);
+    boost::this_thread::disable_interruption dc;
+    boost::this_thread::interruption_point();
+    *failed=false;
+}
+
+void do_test_thread_no_interrupt_if_interrupts_disabled_at_interruption_point()
+{
+    boost::mutex m;
+    bool failed=true;
+    boost::mutex::scoped_lock lk(m);
+    boost::thread thrd(boost::bind(&disabled_interruption_point_thread,&m,&failed));
+    thrd.interrupt();
+    lk.unlock();
+    thrd.join();
+    BOOST_CHECK(!failed);
+}
+
+void test_thread_no_interrupt_if_interrupts_disabled_at_interruption_point()
+{
+    timed_test(&do_test_thread_no_interrupt_if_interrupts_disabled_at_interruption_point, 1);
+}
+
+struct non_copyable_functor:
+    boost::noncopyable
+{
+    unsigned value;
+    
+    non_copyable_functor():
+        value(0)
+    {}
+    
+    void operator()()
+    {
+        value=999;
+    }
+};
+
+void do_test_creation_through_reference_wrapper()
+{
+    non_copyable_functor f;
+    
+    boost::thread thrd(boost::ref(f));
+    thrd.join();
+    BOOST_CHECK_EQUAL(f.value, 999u);
+}
+
+void test_creation_through_reference_wrapper()
+{
+    timed_test(&do_test_creation_through_reference_wrapper, 1);
+}
+
+struct long_running_thread
+{
+    boost::condition_variable cond;
+    boost::mutex mut;
+    bool done;
+    
+    long_running_thread():
+        done(false)
+    {}
+    
+    void operator()()
+    {
+        boost::mutex::scoped_lock lk(mut);
+        while(!done)
+        {
+            cond.wait(lk);
+        }
+    }
+};
+
+void do_test_timed_join()
+{
+    long_running_thread f;
+    boost::thread thrd(boost::ref(f));
+    BOOST_CHECK(thrd.joinable());
+    boost::system_time xt=delay(3);
+    bool const joined=thrd.timed_join(xt);
+    BOOST_CHECK(in_range(boost::get_xtime(xt), 2));
+    BOOST_CHECK(!joined);
+    BOOST_CHECK(thrd.joinable());
+    {
+        boost::mutex::scoped_lock lk(f.mut);
+        f.done=true;
+        f.cond.notify_one();
+    }
+    
+    xt=delay(3);
+    bool const joined2=thrd.timed_join(xt);
+    boost::system_time const now=boost::get_system_time();
+    BOOST_CHECK(xt>now);
+    BOOST_CHECK(joined2);
+    BOOST_CHECK(!thrd.joinable());
+}
+
+void test_timed_join()
+{
+    timed_test(&do_test_timed_join, 10);
+}
+
+
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
     boost::unit_test_framework::test_suite* test =
@@ -71,7 +206,11 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 
     test->add(BOOST_TEST_CASE(test_sleep));
     test->add(BOOST_TEST_CASE(test_creation));
-    test->add(BOOST_TEST_CASE(test_comparison));
+    test->add(BOOST_TEST_CASE(test_id_comparison));
+    test->add(BOOST_TEST_CASE(test_thread_interrupts_at_interruption_point));
+    test->add(BOOST_TEST_CASE(test_thread_no_interrupt_if_interrupts_disabled_at_interruption_point));
+    test->add(BOOST_TEST_CASE(test_creation_through_reference_wrapper));
+    test->add(BOOST_TEST_CASE(test_timed_join));
 
     return test;
 }