Created a branch from trunk

[SVN r38959]
Revive V1 Jamfile to please asio
2026-02-03 09:42:16 +00:00 · 2007-08-26 05:34:35 +00:00 · 2007-08-22 12:40:34 +00:00 · 2007-08-08 19:47:16 +00:00 · 2007-08-08 19:02:26 +00:00 · 2007-04-17 04:44:59 +00:00
31 changed files with 3243 additions and 431 deletions
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -0,0 +1,122 @@
+# 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)
+#
+# Boost.Threads build Jamfile
+#
+# Additional configuration variables used:
+#   See threads.jam.
+
+# Declare the location of this subproject relative to the root.
+subproject libs/thread/build ;
+
+# Include threads.jam for Boost.Threads global build information.
+# This greatly simplifies the Jam code needed to configure the build
+# for the various Win32 build types.
+import ./threads ;
+
+{
+    CPP_SOURCES =
+        barrier
+        condition
+        exceptions
+        mutex
+        once
+        recursive_mutex
+        read_write_mutex
+        thread
+        tss_hooks
+        tss_dll
+        tss_pe
+        tss
+        xtime
+        ;
+
+    template boost_thread_lib_base
+        : ## sources ##
+          <template>thread_base
+          ../src/$(CPP_SOURCES).cpp
+        : ## requirements ##
+          <sysinclude>$(BOOST_ROOT) #:should be unnecessary (because already included in thread_base)
+          <define>BOOST_THREAD_BUILD_LIB=1
+          # the common names rule ensures that the library will
+          # be named according to the rules used by the install
+          # and auto-link features:
+          common-variant-tag
+        : ## default build ##
+    ;
+
+    template boost_thread_dll_base
+        : ## sources ##
+          <template>thread_base
+          ../src/$(CPP_SOURCES).cpp
+        : ## requirements ##
+          <sysinclude>$(BOOST_ROOT) #:should be unnecessary (because already included in thread_base)
+          <define>BOOST_THREAD_BUILD_DLL=1
+          <runtime-link>dynamic
+          # the common names rule ensures that the library will
+          # be named according to the rules used by the install
+          # and auto-link features:
+          common-variant-tag
+        : ## default build ##
+    ;
+
+    lib $(boost_thread_lib_name)
+        : ## sources ##
+          <template>boost_thread_lib_base
+        : ## requirements ##
+          <define>BOOST_THREAD_LIB_NAME=$(boost_thread_lib_name)
+        : ## default build ##
+    ;
+
+    dll $(boost_thread_lib_name)
+        : ## sources ##
+          <template>boost_thread_dll_base
+        : ## requirements ##
+          <define>BOOST_THREAD_LIB_NAME=$(boost_thread_lib_name)
+        : ## default build ##
+    ;
+
+    stage bin-stage
+        : <dll>$(boost_thread_lib_name)
+          <lib>$(boost_thread_lib_name)
+    ;
+
+    install thread lib
+        : <dll>$(boost_thread_lib_name)
+          <lib>$(boost_thread_lib_name)
+    ;
+
+    if $(boost_thread_lib_settings_ptw32)
+    {
+        lib $(boost_thread_lib_name_ptw32)
+            : ## sources ##
+              <template>boost_thread_lib_base
+            : ## requirements ##
+              <define>BOOST_THREAD_LIB_NAME=$(boost_thread_lib_name_ptw32)
+              $(boost_thread_lib_settings_ptw32)
+            : ## default build ##
+        ;
+
+        dll $(boost_thread_lib_name_ptw32)
+            : ## sources ##
+              <template>boost_thread_dll_base
+            : ## requirements ##
+              <define>BOOST_THREAD_LIB_NAME=$(boost_thread_lib_name_ptw32)
+              $(boost_thread_lib_settings_ptw32)
+            : ## default build ##
+        ;
+
+        stage bin-stage
+            : <dll>$(boost_thread_lib_name_ptw32)
+              <lib>$(boost_thread_lib_name_ptw32)
+        ;
+
+        install thread lib
+            : <dll>$(boost_thread_lib_name_ptw32)
+              <lib>$(boost_thread_lib_name_ptw32)
+        ;
+    }
+}
--- a/build/Jamfile.v2
+++ b/build/Jamfile.v2
@@ -20,7 +20,7 @@ CPP_SOURCES =
        mutex
        once
        recursive_mutex
-#        read_write_mutex
+        read_write_mutex
        thread
        tss_hooks
        tss_dll
--- a/build/threads.jam
+++ b/build/threads.jam
@@ -0,0 +1,65 @@
+# 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)
+
+# Additional configuration variables used:
+#   1. PTW32_DIR and PTW32_LIB may be used on Win32 platforms to specify that
+#      a version of Boost.Threads should be built that uses the
+#      the pthreads-win32 library instead of the Win32 native threading APIs.
+#      This feature is mostly used for testing and it's generally recommended
+#      that you use the Win32 native threading libraries instead. 
+#
+#      PTW32_Dir should be set to the installation path of the
+#      pthreads-win32 library and PTW32_LIB should be set to the name of the 
+#      library variant to link against (see the pthreads-win32 documentation).
+#      Example: jam -sPTW32_DIR="c:\pthreads-win32" -sPTW32_LIB="pthreadVCE.lib"
+#      Alternately, environment variables having the names PTW32_DIR and PTW32_LIB
+#      can be set instead of passing these values on the command line.
+#
+#      In either case, libraries having the names boost_thread_ptw32<tags>.dll
+#      and libboost_thread_ptw32<tags>.lib will be built
+#      in addition to the usual boost_thread<tags>.dll and 
+#      libboost_thread<tags>.lib. Link with one of the ptw32 versions
+#      of the Boost.Threads libraries to use the version of Boost.Threads
+#      that is implemented using pthreads-win32 (you will need to #define
+#      BOOST_THREAD_NO_LIB or BOOST_ALL_NO_LIB to disable auto-linking
+#      if your platform supports auto-linking in order to prevent
+#      your build from attempting to link to two different versions of 
+#      the Boost.Threads library).
+
+# Do some OS-specific setup
+{
+    #thread library name
+    boost_thread_lib_name = boost_thread ; 
+    
+    #thread library name with "pthreads-win32" library
+    boost_thread_lib_name_ptw32 = boost_thread_ptw32 ;
+    
+    if $(NT)
+    {
+        if $(PTW32_DIR)
+        {
+            if $(PTW32_LIB)
+            {
+                boost_thread_lib_settings_ptw32 =
+                    <define>BOOST_HAS_PTHREADS
+                    <define>PtW32NoCatchWarn
+                    <include>$(PTW32_DIR)/pre-built/include
+                    <library-file>$(PTW32_DIR)/pre-built/lib/$(PTW32_LIB)
+                ;
+            }
+        }
+    }
+
+    template thread_base
+        : ## sources ##
+        : ## requirements ##
+          <sysinclude>$(BOOST_ROOT)
+          <threading>multi
+          <borland><*><cxxflags>-w-8004
+          <borland><*><cxxflags>-w-8057
+        : ## default build ##
+    ;
+}
--- a/build/threads.mcp
+++ b/build/threads.mcp
--- a/doc/acknowledgements.xml
+++ b/doc/acknowledgements.xml
@@ -63,11 +63,6 @@ last-revision="$Date$">
  Steve Cleary, Steven Kirk, Thomas Holenstein, Thomas Matelich, Trevor
  Perrin, Valentin Bonnard, Vesa Karvonen, Wayne Miller, and William
  Kempf.</para>
-  <para>
-  As of February 2006 Anthony Williams and Roland Schwarz took over maintainance 
-  and further development of the library after it has been in an orphaned state
-  for a rather long period of time. 
-  </para>
  <para>Apologies for anyone inadvertently missed.</para>
 </section>

--- a/doc/build.xml
+++ b/doc/build.xml
@@ -5,7 +5,6 @@
  %thread.entities;
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
-     Copyright (c) 2007 Roland Schwarz
     Subject to the Boost Software License, Version 1.0. 
     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
 -->
@@ -26,112 +25,38 @@
 	</para>
 	<section id="thread.build.building">
 		<title>Building the &Boost.Thread; Libraries</title>
-        <para>
-            Building the &Boost.Thread; Library depends on how you intend to use it. You have several options:
-            <itemizedlist>
-                <listitem>
-                    Using as a <link linkend="thread.build.precompiled">precompiled</link> library, possibly
-                    with auto-linking, or for use from within an IDE.
-                </listitem>
-                <listitem>
-                    Use from a <link linkend="thread.build.bjam">&Boost.Build;</link> project.
-                </listitem>
-                <listitem>
-                    Using in <link linkend="thread.build.source">source</link> form.
-                </listitem>
-            </itemizedlist>
-        </para>
-        <section id="thread.build.precompiled">
-            <title>Precompiled</title>
-            <para>
-                Using the &Boost.Thread; library in precompiled form is the way to go if you want to
-                install the library to a standard place, from where your linker is able to resolve code
-                in binary form. You also will want this option if compile time is a concern. Multiple 
-                variants are available, for different toolsets and build variants (debug/release).
-                The library files are named <emphasis>{lead}boost_thread{build-specific-tags}.{extension}</emphasis>,
-                where the build-specific-tags indicate the toolset used to build the library, whether it's
-                a debug or release build, what version of &Boost; was used, etc.; and the lead and extension
-                are the appropriate extensions for a dynamic link library or static library for the platform
-                for which &Boost.Thread; is being built.
-            	For instance, a debug build of the dynamic library built for Win32 with VC++ 7.1 using Boost 1.34 would
-            	be named <emphasis>boost_thread-vc71-mt-gd-1_34.dll</emphasis>.
-                More information on this should be available from the &Boost.Build; documentation.
-            </para>
-            <para>
-                Building should be possible with the default configuration. If you are running into problems,
-                it might be wise to adjust your local settings of &Boost.Build; though. Typically you will
-                need to get your user-config.jam file to reflect your environment, i.e. used toolsets. Please
-                refer to the &Boost.Build; documentation to learn how to do this.
-            </para>
-            <para>
-                To create the libraries you need to open a command shell and change to the 
-                <emphasis>boost_root</emphasis> directory. From there you give the command 
-                <programlisting>bjam --toolset=<emphasis>mytoolset</emphasis> stage --with-thread</programlisting>
-                Replace <emphasis>mytoolset</emphasis> with the name of your toolset, e.g. msvc-7.1 .
-                This will compile and put the libraries into the <emphasis>stage</emphasis> directory which is just below the
-                <emphasis>boost_root</emphasis> directory. &Boost.Build; by default will generate static and 
-                dynamic variants for debug and release.
-            </para>
-            <note>
-                Invoking the above command without the --with-thread switch &Boost.Build; will build all of 
-	            the Boost distribution, including &Boost.Thread;.
-            </note>
-            <para>
-                The next step is to copy your libraries to a place where your linker is able to pick them up.
-                It is also quite possible to leave them in the stage directory and instruct your IDE to take them
-                from there.
-            </para>
-            <para>
-                In your IDE you then need to add <emphasis>boost_root</emphasis>/boost to the paths where the compiler
-                expects to find files to be included. For toolsets that support <emphasis>auto-linking</emphasis>
-                it is not necessary to explicitly specify the name of the library to link against, it is sufficient
-                to specify the path of the stage directory. Typically this is true on Windows. For gcc you need 
-                to specify the exact library name (including all the tags). Please don't forget that threading
-                support must be turned on to be able to use the library. You should be able now to build your
-                project from the IDE.
-            </para>
-	    </section>
-        <section id="thread.build.bjam">
-            <title>&Boost.Build; Project</title>
-            <para>
-                If you have decided to use &Boost.Build; as a build environment for your application, you simply
-                need to add a single line to your <emphasis>Jamroot</emphasis> file:
-                <programlisting>use-project /boost : {path-to-boost-root} ;</programlisting>
-                where <emphasis>{path-to-boost-root}</emphasis> needs to be replaced with the location of
-                your copy of the boost tree.
-                Later when you specify a component that needs to link against &Boost.Thread; you specify this
-                as e.g.:
-                <programlisting>exe myapp : {myappsources} /boost//thread ;</programlisting>
-                and you are done.
-            </para>
-        </section>
-        <section id="thread.build.source">
-            <title>Source Form</title>
-            <para>
-                Of course it is also possible to use the &Boost.Thread; library in source form.
-                First you need to specify the <emphasis>boost_root</emphasis>/boost directory as
-                a path where your compiler expects to find files to include. It is not easy
-                to isolate the &Boost.Thread; include files from the rest of the boost 
-                library though. You would also need to isolate every include file that the thread
-                library depends on. Next you need to copy the files from 
-                <emphasis>boost_root</emphasis>/libs/thread/src to your project and instruct your
-                build system to compile them together with your project. Please look into the
-                <emphasis>Jamfile</emphasis> in <emphasis>boost_root</emphasis>/libs/thread/build
-                to find out which compiler options and defines you will need to get a clean compile.
-                Using the boost library in this way is the least recommended, and should only be
-                considered if avoiding dependency on &Boost.Build; is a requirement. Even if so
-                it might be a better option to use the library in it's precompiled form. 
-                Precompiled downloads are available from the boost consulting web site, or as
-                part of most linux distributions.
-            </para>
-        </section>
+		<para>
+	To build the &Boost.Thread; libraries using &Boost.Build;, simply change to the
+	directory <emphasis>boost_root</emphasis>/libs/thread/build and execute the command:
+		<programlisting>bjam -sTOOLS=<emphasis>toolset</emphasis></programlisting>
+	This will create the debug and the release builds of the &Boost.Thread; library.
+	<note>Invoking the above command in <emphasis>boost_root</emphasis> will build all of 
+	the Boost distribution, including &Boost.Thread;.</note>
+		</para>
+		<para>
+	The Jamfile supplied with &Boost.Thread; produces a dynamic link library named
+	<emphasis>boost_thread{build-specific-tags}.{extension}</emphasis>, where the build-specific
+	tags indicate the toolset used to build the library, whether it's a debug or release
+	build, what version of Boost was used, etc.; and the extension is the appropriate extension
+	for a dynamic link library for the platform for which &Boost.Thread; is being built.
+	For instance, a debug library built for Win32 with VC++ 7.1 using Boost 1.31 would
+	be named <emphasis>boost_thread-vc71-mt-gd-1_31.dll</emphasis>.
+		</para>
+		<para>
+	The source files that are used to create the &Boost.Thread; library
+	are all of the *.cpp files found in <emphasis>boost_root</emphasis>/libs/thread/src.
+	These need to be built with the compiler's and linker's multi-threading support enabled.
+	If you want to create your own build solution you'll have to follow these same
+	guidelines. One of the most frequently reported problems when trying to do this
+	occurs from not enabling the compiler's and linker's support for multi-threading.
+		</para>
 	</section>
 	<section id="thread.build.testing">
 		<title>Testing the &Boost.Thread; Libraries</title>
 		<para>
-	        To test the &Boost.Thread; libraries using &Boost.Build;, simply change to the
-	        directory <emphasis>boost_root</emphasis>/libs/thread/test and execute the command:
-			<programlisting>bjam --toolset=<emphasis>mytoolset</emphasis> test</programlisting>
+	To test the &Boost.Thread; libraries using &Boost.Build;, simply change to the
+	directory <emphasis>boost_root</emphasis>/libs/thread/test and execute the command:
+			<programlisting>bjam -sTOOLS=<emphasis>toolset</emphasis> test</programlisting>
 		</para>
 	</section>
 </section>
--- a/doc/concepts.xml
+++ b/doc/concepts.xml
@@ -18,17 +18,7 @@
 	which allow only one thread at a time to access a resource when it is
 	being modified (the "Write" part of Read/Write), but allows multiple threads
 	to access a resource when it is only being referenced (the "Read" part of
-    Read/Write).</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>
+	Read/Write).</para>

 	<section id="thread.concepts.mutexes">
 		<title>Mutexes</title>
@@ -749,18 +739,13 @@

 	<section id="thread.concepts.read-write-mutexes">
 	<title>Read/Write Mutexes</title>
-        <note> Unfortunately it turned out that the current implementation 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>
+		<note>Since the read/write mutex and related classes are new,
+		both interface and implementation are liable to change
+		in future releases of &Boost.Thread;.
+		The lock concepts and lock promotion and demotion in particular 
+		are still under discussion and very likely to change.</note>

-        <para>A read/write mutex (short for reader/writer mutual-exclusion) object
+		<para>A read/write mutex (short for reader/writer mutual-exclusion) object
 		is used to serialize access to a resource shared between multiple 
 		threads, where multiple "readers" can share simultaneous access, but 
 		"writers" require exclusive access. The
--- a/doc/entities.xml
+++ b/doc/entities.xml
@@ -2,7 +2,6 @@
     Subject to the Boost Software License, Version 1.0. 
     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
 -->
-<!ENTITY Boost "<emphasis role='bold'>Boost</emphasis>">
 <!ENTITY Boost.Thread "<emphasis role='bold'>Boost.Thread</emphasis>">
 <!ENTITY Boost.Build "<emphasis role='bold'>Boost.Build</emphasis>">
 <!ENTITY cite.AndrewsSchneider83  "<citation><xref
--- a/doc/reference.xml
+++ b/doc/reference.xml
@@ -17,12 +17,6 @@
  <xi:include href="mutex-ref.xml"/>
  <xi:include href="once-ref.xml"/>
  <xi:include href="recursive_mutex-ref.xml"/>
-<!--
-  The read_write_mutex is held back from release, since the
-  implementation suffers from a serious, yet unresolved bug.
-  The implementation is likely to appear in a reworked
-  form in the next release.
-->
  <xi:include href="read_write_mutex-ref.xml"/>
  <xi:include href="thread-ref.xml"/>
  <xi:include href="tss-ref.xml"/>
--- a/doc/release_notes.xml
+++ b/doc/release_notes.xml
@@ -10,63 +10,7 @@
 -->
 <section id="thread.release_notes" last-revision="$Date$">
 	<title>Release Notes</title>
-    <section id="thread.release_notes.boost_1_34_0">
-        <title>Boost 1.34.0</title>
-
-        <section id="thread.release_notes.boost_1_34_0.change_log.maintainance">
-            <title>New team of maintainers</title>
-
-            <para>
-                Since the original author William E. Kempf no longer is available to
-                maintain the &Boost.Thread; library, a new team has been formed
-                in an attempt to continue the work on &Boost.Thread;.
-                Fortunately William E. Kempf has given
-                <ulink url="http://lists.boost.org/Archives/boost/2006/09/110143.php">
-                    permission </ulink> 
-                to use his work under the boost license.
-            </para>
-            <para>
-                The team currently consists of
-                <itemizedlist>
-                    <listitem>
-                        Anthony Williams, for the Win32 platform,
-                    </listitem>
-                    <listitem>
-                        Roland Schwarz, for the linux platform, and various "housekeeping" tasks.
-                    </listitem>
-                </itemizedlist>
-                Volunteers for other platforms are welcome!
-            </para>
-            <para>
-                As the &Boost.Thread; was kind of orphaned over the last release, this release
-                attempts to fix the known bugs. Upcoming releases will bring in new things.
-            </para>
-        </section>
-
-        <section id="thread.release_notes.boost_1_34_0.change_log.read_write_mutex">
-            <title>read_write_mutex still broken</title>
-
-            <para>
-                <note>
-                    It has been decided not to release the Read/Write Mutex, since the current
-                    implementation suffers from a serious bug. The documentation of the concepts
-                    has been included though, giving the interested reader an opportunity to study the
-                    original concepts. Please refer to the following links if you are interested
-                    which problems led to the decision to held back this mutex type.The issue
-                    has been discovered before 1.33 was released and the code has
-                    been omitted from that release. A reworked mutex is expected to appear in 1.35.
-                    Also see:  
-                    <ulink url="http://lists.boost.org/Archives/boost/2005/08/92307.php">
-                        read_write_mutex bug</ulink> 
-                    and 
-                    <ulink url="http://lists.boost.org/Archives/boost/2005/09/93180.php">
-                        read_write_mutex fundamentally broken in 1.33</ulink>
-                </note>
-            </para>
-        </section>
-
-    </section>
-    <section id="thread.release_notes.boost_1_32_0">
+	<section id="thread.release_notes.boost_1_32_0">
 		<title>Boost 1.32.0</title>

 		<section id="thread.release_notes.boost_1_32_0.change_log.documentation">
--- a/doc/thread-ref.xml
+++ b/doc/thread-ref.xml
@@ -264,7 +264,20 @@
 				<effects>Calls <code>join()</code> on each of the managed 
 				<classname>thread</classname> objects.</effects>
 			</method>
-		</method-group>
+        </method-group>
+        
+        <method-group name="capacity">
+            
+            <method name="size" cv="const">
+                <type>int</type>
+                
+                <returns>the number of <classname>thread</classname> 
+                    objects in the group
+                </returns>
+
+            </method>
+
+        </method-group>
 	</class>
  </namespace>
 </header>
--- a/include/boost/thread/barrier.hpp
+++ b/include/boost/thread/barrier.hpp
@@ -29,7 +29,7 @@ private:
 #ifdef BOOST_MSVC
 #   pragma warning(push)
 #   pragma warning(disable: 4251 4231 4660 4275)
-#endif
+#endif    
    condition m_cond;
 #ifdef BOOST_MSVC
 #   pragma warning(pop)
--- a/include/boost/thread/condition.hpp
+++ b/include/boost/thread/condition.hpp
@@ -28,7 +28,6 @@ struct xtime;
 #   pragma warning(push)
 #   pragma warning(disable: 4251 4231 4660 4275)
 #endif
-
 namespace detail {

 class BOOST_THREAD_DECL condition_impl : private noncopyable
--- a/include/boost/thread/mutex.hpp
+++ b/include/boost/thread/mutex.hpp
@@ -29,7 +29,6 @@ struct xtime;
 #   pragma warning(push)
 #   pragma warning(disable: 4251 4231 4660 4275)
 #endif
-
 class BOOST_THREAD_DECL mutex
    : private noncopyable
 {
--- a/include/boost/thread/read_write_mutex.hpp
+++ b/include/boost/thread/read_write_mutex.hpp
@@ -0,0 +1,285 @@
+// Copyright (C)  2002-2003
+// David Moore, William E. Kempf, Michael Glassford
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// A Boost::threads implementation of a synchronization
+//   primitive which can allow multiple readers or a single
+//   writer to have access to a shared resource.
+
+#ifndef BOOST_READ_WRITE_MUTEX_JDM030602_HPP
+#define BOOST_READ_WRITE_MUTEX_JDM030602_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/utility.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/detail/lock.hpp>
+#include <boost/thread/detail/read_write_lock.hpp>
+#include <boost/thread/condition.hpp>
+
+namespace boost {
+// 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 read_write_scheduling_policy {
+    enum read_write_scheduling_policy_enum
+    {
+        writer_priority,               //Prefer writers; can starve readers
+        reader_priority,               //Prefer readers; can starve writers
+        alternating_many_reads,        //Alternate readers and writers; before a writer, release all queued readers 
+        alternating_single_read        //Alternate readers and writers; before a writer, release only one queued reader
+    };
+} // namespace read_write_scheduling_policy
+
+namespace detail {
+
+namespace thread {
+
+// Shared implementation construct for explicit Scheduling Policies
+// This implementation is susceptible to self-deadlock, though....
+template<typename Mutex>
+struct read_write_mutex_impl
+{
+    typedef Mutex mutex_type;
+    typedef detail::thread::scoped_lock<Mutex> scoped_lock;
+    typedef detail::thread::scoped_try_lock<Mutex> scoped_try_lock;
+    typedef detail::thread::scoped_timed_lock<Mutex> scoped_timed_lock;
+
+    read_write_mutex_impl(read_write_scheduling_policy::read_write_scheduling_policy_enum sp);
+#if !BOOST_WORKAROUND(__BORLANDC__,<= 0x564)
+    ~read_write_mutex_impl();
+#endif
+
+    Mutex m_prot;
+
+    const read_write_scheduling_policy::read_write_scheduling_policy_enum m_sp;
+    int m_state; //-1 = write lock; 0 = unlocked; >0 = read locked
+
+    boost::condition m_waiting_writers;
+    boost::condition m_waiting_readers;
+    boost::condition m_waiting_promotion;
+    int m_num_waiting_writers;
+    int m_num_waiting_readers;
+    bool m_state_waiting_promotion;
+
+    int m_num_waking_writers;
+    int m_num_waking_readers;
+    int m_num_max_waking_writers; //Debug only
+    int m_num_max_waking_readers; //Debug only
+
+    bool m_readers_next;
+
+    void do_read_lock();
+    void do_write_lock();
+    void do_write_unlock();
+    void do_read_unlock();
+    bool do_try_write_lock();
+    bool do_try_read_lock();
+    bool do_timed_write_lock(const xtime &xt);
+    bool do_timed_read_lock(const xtime &xt);
+
+    void do_demote_to_read_lock();
+    bool do_try_demote_to_read_lock();
+    bool do_timed_demote_to_read_lock(const xtime &xt);
+
+    void do_promote_to_write_lock();
+    bool do_try_promote_to_write_lock();
+    bool do_timed_promote_to_write_lock(const xtime &xt);
+
+    bool locked();
+    read_write_lock_state::read_write_lock_state_enum state();
+
+private:
+
+    bool do_demote_to_read_lock_impl();
+
+    enum scheduling_reason
+    {
+        scheduling_reason_unlock,
+        scheduling_reason_timeout,
+        scheduling_reason_demote
+    };
+
+    void do_scheduling_impl(const scheduling_reason reason);
+    bool do_wake_one_reader(void);
+    bool do_wake_all_readers(void);
+    bool do_wake_writer(void);
+    bool waker_exists(void);
+};
+
+} // namespace detail
+
+} // namespace thread
+
+class BOOST_THREAD_DECL read_write_mutex : private noncopyable
+{
+public:
+
+    read_write_mutex(read_write_scheduling_policy::read_write_scheduling_policy_enum sp);
+    ~read_write_mutex();
+
+    read_write_scheduling_policy::read_write_scheduling_policy_enum policy() const { return m_impl.m_sp; }
+
+    friend class detail::thread::read_write_lock_ops<read_write_mutex>;
+
+    typedef detail::thread::scoped_read_write_lock<
+        read_write_mutex> scoped_read_write_lock;
+
+    typedef detail::thread::scoped_read_lock<
+        read_write_mutex> scoped_read_lock;
+
+    typedef detail::thread::scoped_write_lock<
+        read_write_mutex> scoped_write_lock;
+
+private:
+
+    // Operations that will eventually be done only
+    //   via lock types
+    void do_write_lock();
+    void do_read_lock();
+    void do_write_unlock();
+    void do_read_unlock();
+
+    void do_demote_to_read_lock();
+
+    void do_promote_to_write_lock();
+
+    bool locked();
+    read_write_lock_state::read_write_lock_state_enum state();
+
+    detail::thread::read_write_mutex_impl<mutex> m_impl; 
+};
+
+class BOOST_THREAD_DECL try_read_write_mutex : private noncopyable
+{
+public:
+
+    try_read_write_mutex(read_write_scheduling_policy::read_write_scheduling_policy_enum sp);
+    ~try_read_write_mutex();
+
+    read_write_scheduling_policy::read_write_scheduling_policy_enum policy() const { return m_impl.m_sp; }
+
+    friend class detail::thread::read_write_lock_ops<try_read_write_mutex>;
+
+    typedef detail::thread::scoped_read_write_lock<
+        try_read_write_mutex> scoped_read_write_lock;
+    typedef detail::thread::scoped_try_read_write_lock<
+        try_read_write_mutex> scoped_try_read_write_lock;
+
+    typedef detail::thread::scoped_read_lock<
+        try_read_write_mutex> scoped_read_lock;
+    typedef detail::thread::scoped_try_read_lock<
+        try_read_write_mutex> scoped_try_read_lock;
+
+    typedef detail::thread::scoped_write_lock<
+        try_read_write_mutex> scoped_write_lock;
+    typedef detail::thread::scoped_try_write_lock<
+        try_read_write_mutex> scoped_try_write_lock;
+
+private:
+
+    // Operations that will eventually be done only
+    //   via lock types
+    void do_write_lock();
+    void do_read_lock();
+    void do_write_unlock();
+    void do_read_unlock();
+    bool do_try_write_lock();
+    bool do_try_read_lock();
+
+
+    void do_demote_to_read_lock();
+    bool do_try_demote_to_read_lock();
+
+    void do_promote_to_write_lock();
+    bool do_try_promote_to_write_lock();
+
+    bool locked();
+    read_write_lock_state::read_write_lock_state_enum state();
+
+    detail::thread::read_write_mutex_impl<try_mutex> m_impl; 
+};
+
+class BOOST_THREAD_DECL timed_read_write_mutex : private noncopyable
+{
+public:
+
+    timed_read_write_mutex(read_write_scheduling_policy::read_write_scheduling_policy_enum sp);
+    ~timed_read_write_mutex();
+
+    read_write_scheduling_policy::read_write_scheduling_policy_enum policy() const { return m_impl.m_sp; }
+
+    friend class detail::thread::read_write_lock_ops<timed_read_write_mutex>;
+
+    typedef detail::thread::scoped_read_write_lock<
+        timed_read_write_mutex> scoped_read_write_lock;
+    typedef detail::thread::scoped_try_read_write_lock<
+        timed_read_write_mutex> scoped_try_read_write_lock;
+    typedef detail::thread::scoped_timed_read_write_lock<
+        timed_read_write_mutex> scoped_timed_read_write_lock;
+
+    typedef detail::thread::scoped_read_lock<
+        timed_read_write_mutex> scoped_read_lock;
+    typedef detail::thread::scoped_try_read_lock<
+        timed_read_write_mutex> scoped_try_read_lock;
+    typedef detail::thread::scoped_timed_read_lock<
+        timed_read_write_mutex> scoped_timed_read_lock;
+
+    typedef detail::thread::scoped_write_lock<
+        timed_read_write_mutex> scoped_write_lock;
+    typedef detail::thread::scoped_try_write_lock<
+        timed_read_write_mutex> scoped_try_write_lock;
+    typedef detail::thread::scoped_timed_write_lock<
+        timed_read_write_mutex> scoped_timed_write_lock;
+
+private:
+
+    // Operations that will eventually be done only
+    //   via lock types
+    void do_write_lock();
+    void do_read_lock();
+    void do_write_unlock();
+    void do_read_unlock();
+    bool do_try_write_lock();
+    bool do_try_read_lock();
+    bool do_timed_write_lock(const xtime &xt);
+    bool do_timed_read_lock(const xtime &xt);
+    
+    void do_demote_to_read_lock();
+    bool do_try_demote_to_read_lock();
+    bool do_timed_demote_to_read_lock(const xtime &xt);
+
+    void do_promote_to_write_lock();
+    bool do_try_promote_to_write_lock();
+    bool do_timed_promote_to_write_lock(const xtime &xt);
+
+    bool locked();
+    read_write_lock_state::read_write_lock_state_enum state();
+
+    detail::thread::read_write_mutex_impl<timed_mutex> m_impl; 
+};
+#ifdef BOOST_MSVC
+#   pragma warning(pop)
+#endif
+}    // namespace boost
+
+#endif
+
+// Change Log:
+//  10 Mar 02 
+//      Original version.
+//   4 May 04 GlassfordM
+//      Implement lock promotion and demotion.
+//      Add locked() and state() member functions for debugging
+//         (should these be made public?).
+//      Rename to improve consistency and eliminate abbreviations:
+//          Use "read" and "write" instead of "shared" and "exclusive".
+//          Change "rd" to "read", "wr" to "write", "rw" to "read_write".
+//      Add mutex_type typdef.
--- a/include/boost/thread/thread.hpp
+++ b/include/boost/thread/thread.hpp
@@ -70,7 +70,7 @@ public:
    void add_thread(thread* thrd);
    void remove_thread(thread* thrd);
    void join_all();
-        int size();
+        int size() const;

 private:
    std::list<thread*> m_threads;
--- a/include/boost/thread/tss.hpp
+++ b/include/boost/thread/tss.hpp
@@ -45,7 +45,6 @@ public:
            throw boost::thread_resource_error();
        }
    }
-
    ~tss();
    void* get() const;
    void set(void* value);
--- a/src/condition.cpp
+++ b/src/condition.cpp
@@ -27,12 +27,6 @@
 #   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 {
@@ -379,20 +373,6 @@ bool condition_impl::do_timed_wait(const xtime& xt, pthread_mutex_t* pmutex)

    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;
--- a/src/mutex.inl
+++ b/src/mutex.inl
@@ -62,8 +62,10 @@ inline void* new_critical_section()
 inline void* new_mutex(const char* name)
 {
 #if defined(BOOST_NO_ANSI_APIS)
-    USES_CONVERSION;
-    HANDLE mutex = CreateMutexW(0, 0, A2CW(name));
+    int num_wide_chars = (strlen(name) + 1);
+    LPWSTR wide_name = (LPWSTR)_alloca( num_wide_chars * 2 );
+    ::MultiByteToWideChar(CP_ACP, 0, name, -1, wide_name, num_wide_chars);
+    HANDLE mutex = CreateMutexW(0, 0, wide_name);
 #else
    HANDLE mutex = CreateMutexA(0, 0, name);
 #endif
--- a/src/once.cpp
+++ b/src/once.cpp
@@ -9,6 +9,7 @@
 #include <boost/detail/workaround.hpp>

 #include <boost/thread/once.hpp>
+#include <boost/thread/exceptions.hpp>
 #include <cstdio>
 #include <cassert>

@@ -18,6 +19,7 @@
      using std::size_t;
 #   endif
 #   include <windows.h>
+#   include "mutex.inl"
 #   if defined(BOOST_NO_STRINGSTREAM)
 #       include <strstream>

@@ -114,11 +116,8 @@ inline LONG ice_wrapper(LPVOID (__stdcall *ice)(LPVOID*, LPVOID, LPVOID),
 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 InterlockedCompareExchange(dest, exch, cmp);
+#else
    return ice_wrapper(&InterlockedCompareExchange, dest, exch, cmp);
 #endif
 }
@@ -140,12 +139,7 @@ void call_once(void (*func)(), once_flag& flag)
             << &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
+        HANDLE mutex=new_mutex(strm.str());
 #else
 #   if defined (BOOST_NO_ANSI_APIS)
        std::wostringstream strm;
--- a/src/read_write_mutex.cpp
+++ b/src/read_write_mutex.cpp
--- a/src/recursive_mutex.cpp
+++ b/src/recursive_mutex.cpp
@@ -291,8 +291,7 @@ recursive_mutex::recursive_mutex()

    res = pthread_mutex_init(&m_mutex, &attr);
    {
-        int res = 0;
-        res = pthread_mutexattr_destroy(&attr);
+        int res = pthread_mutexattr_destroy(&attr);
        assert(res == 0);
    }
    if (res != 0)
@@ -448,8 +447,7 @@ recursive_try_mutex::recursive_try_mutex()

    res = pthread_mutex_init(&m_mutex, &attr);
    {
-        int res = 0;
-        res = pthread_mutexattr_destroy(&attr);
+        int res = pthread_mutexattr_destroy(&attr);
        assert(res == 0);
    }
    if (res != 0)
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -89,6 +89,18 @@ public:
    bool m_started;
 };

+#if defined(BOOST_HAS_WINTHREADS)
+
+struct on_thread_exit_guard
+{
+    ~on_thread_exit_guard()
+    {
+        on_thread_exit();
+    }
+};
+
+#endif
+
 } // unnamed namespace

 extern "C" {
@@ -100,22 +112,25 @@ extern "C" {
        static OSStatus thread_proxy(void* param)
 #endif
    {
-        //try
-        //{
+//        try
+        {
+#if defined(BOOST_HAS_WINTHREADS)
+
+            on_thread_exit_guard guard;
+
+#endif
+
            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
-        //}
+        }
+//        catch (...)
+//        {
+//#if defined(BOOST_HAS_WINTHREADS)
+//            on_thread_exit();
+//#endif
+//        }
 #if defined(BOOST_HAS_MPTASKS)
        ::boost::detail::thread_cleanup();
 #endif
@@ -363,7 +378,7 @@ void thread_group::join_all()
    }
 }

-int thread_group::size()
+int thread_group::size() const
 {
        return m_threads.size();
 }
--- a/src/timeconv.inl
+++ b/src/timeconv.inl
@@ -3,7 +3,6 @@
 //
 //  Distributed under the 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 {
--- a/src/tss.cpp
+++ b/src/tss.cpp
@@ -84,8 +84,7 @@ extern "C" void cleanup_slots(void* p)

 void init_tss_data()
 {
-    std::auto_ptr<tss_data_cleanup_handlers_type> 
-        temp(new tss_data_cleanup_handlers_type);
+    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)
@@ -99,6 +98,7 @@ void init_tss_data()
    tss_data_native_key = TlsAlloc();
    if (tss_data_native_key == 0xFFFFFFFF)
        return;
+
 #elif defined(BOOST_HAS_PTHREADS)
    int res = pthread_key_create(&tss_data_native_key, &cleanup_slots);
    if (res != 0)
--- a/src/tss_hooks.cpp
+++ b/src/tss_hooks.cpp
@@ -1,5 +1,7 @@
-// Copyright (C) 2004 Michael Glassford
-// Copyright (C) 2006 Roland Schwarz
+// (C) Copyright Michael Glassford 2004.
+// Copyright (c) 2006 Peter Dimov
+// Copyright (c) 2006 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)
@@ -8,205 +10,152 @@

 #if defined(BOOST_HAS_WINTHREADS)

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

-    #include <boost/assert.hpp>
-//    #include <boost/thread/mutex.hpp>
-    #include <boost/thread/once.hpp>
+#include <boost/assert.hpp>
+#include <boost/thread/once.hpp>

-    #include <list>
+#include <list>

-    #define WIN32_LEAN_AND_MEAN
-    #include <windows.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>

-    namespace
+namespace
+{
+
+typedef std::list<thread_exit_handler> thread_exit_handlers;
+
+const DWORD invalid_tls_key = TLS_OUT_OF_INDEXES;
+DWORD tls_key = invalid_tls_key;
+
+boost::once_flag once_init_tls_key = BOOST_ONCE_INIT;
+
+void init_tls_key()
+{
+    tls_key = TlsAlloc();
+}
+
+} // unnamed namespace
+
+extern "C" BOOST_THREAD_DECL int at_thread_exit( thread_exit_handler exit_handler )
+{
+    boost::call_once( init_tls_key, once_init_tls_key );
+
+    if( tls_key == invalid_tls_key )
    {
-        class CScopedCSLock
-        {
-        public:
-            CScopedCSLock(LPCRITICAL_SECTION cs) : cs(cs), lk(true) {
-                ::EnterCriticalSection(cs);
-            }
-            ~CScopedCSLock() {
-                if (lk) ::LeaveCriticalSection(cs);
-            }
-            void Unlock() {
-                lk = false;
-                ::LeaveCriticalSection(cs);
-            }
-        private:
-            bool lk;
-            LPCRITICAL_SECTION cs;
-        };
-
-        typedef std::list<thread_exit_handler> thread_exit_handlers;
-
-        boost::once_flag once_init_threadmon_mutex = BOOST_ONCE_INIT;
-        //boost::mutex* threadmon_mutex;
-        // We don't use boost::mutex here, to avoid a memory leak report,
-        // because we cannot delete it again easily.
-        CRITICAL_SECTION threadmon_mutex;
-        void init_threadmon_mutex(void)
-        {
-            //threadmon_mutex = new boost::mutex;
-            //if (!threadmon_mutex)
-            //    throw boost::thread_resource_error();
-            ::InitializeCriticalSection(&threadmon_mutex);
-        }
-
-        const DWORD invalid_tls_key = TLS_OUT_OF_INDEXES;
-        DWORD tls_key = invalid_tls_key;
-
-        unsigned long attached_thread_count = 0;
+        return -1;
    }

-    /*
-    Calls to DllMain() and tls_callback() are serialized by the OS;
-    however, calls to at_thread_exit are not, so it must be protected
-    by a mutex. Since we already need a mutex for at_thread_exit(),
-    and since there is no guarantee that on_process_enter(),
-    on_process_exit(), on_thread_enter(), and on_thread_exit()
-    will be called only from DllMain() or tls_callback(), it makes
-    sense to protect those, too.
-    */
+    // Get the exit handlers list for the current thread from tls.

-    extern "C" BOOST_THREAD_DECL int at_thread_exit(
-        thread_exit_handler exit_handler
-        )
+    thread_exit_handlers* exit_handlers =
+        static_cast< thread_exit_handlers* >( TlsGetValue( tls_key ) );
+
+    if( exit_handlers == 0 )
    {
-        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
-        //boost::mutex::scoped_lock lock(*threadmon_mutex);
-        CScopedCSLock lock(&threadmon_mutex);
-
-        //Allocate a tls slot if necessary.
-
-        if (tls_key == invalid_tls_key)
-            tls_key = TlsAlloc();
-
-        if (tls_key == invalid_tls_key)
-            return -1;
-
-        //Get the exit handlers list for the current thread from tls.
-
-        thread_exit_handlers* exit_handlers =
-            static_cast<thread_exit_handlers*>(TlsGetValue(tls_key));
-
-        if (!exit_handlers)
-        {
-            //No exit handlers list was created yet.
-
-            try
-            {
-                //Attempt to create a new exit handlers list.
-
-                exit_handlers = new thread_exit_handlers;
-                if (!exit_handlers)
-                    return -1;
-
-                //Attempt to store the list pointer in tls.
-
-                if (TlsSetValue(tls_key, exit_handlers))
-                    ++attached_thread_count;
-                else
-                {
-                    delete exit_handlers;
-                    return -1;
-                }
-            }
-            catch (...)
-            {
-                return -1;
-            }
-        }
-
-        //Like the C runtime library atexit() function,
-        //functions should be called in the reverse of
-        //the order they are added, so push them on the
-        //front of the list.
+        // No exit handlers list was created yet.

        try
        {
-            exit_handlers->push_front(exit_handler);
+            // Attempt to create a new exit handlers list.
+
+            exit_handlers = new thread_exit_handlers;
+
+            if( exit_handlers == 0 )
+            {
+                return -1;
+            }
+
+            // Attempt to store the list pointer in tls.
+
+            if( !TlsSetValue( tls_key, exit_handlers ) )
+            {
+                delete exit_handlers;
+                return -1;
+            }
        }
-        catch (...)
+        catch( ... )
        {
            return -1;
        }
-
-        //Like the atexit() function, a result of zero
-        //indicates success.
-
-        return 0;
    }

-    extern "C" BOOST_THREAD_DECL void on_process_enter(void)
-    {
-        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
-//        boost::mutex::scoped_lock lock(*threadmon_mutex);
-        CScopedCSLock lock(&threadmon_mutex);
+    // Like the C runtime library atexit() function,
+    // functions should be called in the reverse of
+    // the order they are added, so push them on the
+    // front of the list.

-        BOOST_ASSERT(attached_thread_count == 0);
+    try
+    {
+        exit_handlers->push_front( exit_handler );
+    }
+    catch( ... )
+    {
+        return -1;
    }

-    extern "C" BOOST_THREAD_DECL void on_process_exit(void)
+    // Like the atexit() function, a result of zero
+    // indicates success.
+
+    return 0;
+}
+
+extern "C" BOOST_THREAD_DECL void on_process_enter()
+{
+}
+
+extern "C" BOOST_THREAD_DECL void on_process_exit()
+{
+    if( tls_key != invalid_tls_key )
    {
-        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
-//        boost::mutex::scoped_lock lock(*threadmon_mutex);
-        CScopedCSLock lock(&threadmon_mutex);
+        TlsFree(tls_key);
+    }
+}

-        BOOST_ASSERT(attached_thread_count == 0);
+extern "C" BOOST_THREAD_DECL void on_thread_enter()
+{
+}

-        //Free the tls slot if one was allocated.
+extern "C" BOOST_THREAD_DECL void on_thread_exit()
+{
+    // Initializing tls_key here ensures its proper visibility
+    boost::call_once( init_tls_key, once_init_tls_key );

-        if (tls_key != invalid_tls_key)
+    // Get the exit handlers list for the current thread from tls.
+
+    if( tls_key == invalid_tls_key )
+    {
+        return;
+    }
+
+    thread_exit_handlers* exit_handlers =
+        static_cast< thread_exit_handlers* >( TlsGetValue( tls_key ) );
+
+    // If a handlers list was found, invoke its handlers.
+
+    if( exit_handlers != 0 )
+    {
+        // Call each handler and remove it from the list
+
+        while( !exit_handlers->empty() )
        {
-            TlsFree(tls_key);
-            tls_key = invalid_tls_key;
-        }
-    }
-
-    extern "C" BOOST_THREAD_DECL void on_thread_enter(void)
-    {
-        //boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
-        //boost::mutex::scoped_lock lock(*threadmon_mutex);
-    }
-
-    extern "C" BOOST_THREAD_DECL void on_thread_exit(void)
-    {
-        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
-//        boost::mutex::scoped_lock lock(*threadmon_mutex);
-        CScopedCSLock lock(&threadmon_mutex);
-
-        //Get the exit handlers list for the current thread from tls.
-
-        if (tls_key == invalid_tls_key)
-            return;
-
-        thread_exit_handlers* exit_handlers =
-            static_cast<thread_exit_handlers*>(TlsGetValue(tls_key));
-
-        //If a handlers list was found, use it.
-
-        if (exit_handlers && TlsSetValue(tls_key, 0))
-        {
-            BOOST_ASSERT(attached_thread_count > 0);
-            --attached_thread_count;
-
-            //lock.unlock();
-            lock.Unlock();
-
-            //Call each handler and remove it from the list
-
-            while (!exit_handlers->empty())
+            if( thread_exit_handler exit_handler = *exit_handlers->begin() )
            {
-                if (thread_exit_handler exit_handler = *exit_handlers->begin())
-                    (*exit_handler)();
-                exit_handlers->pop_front();
+                (*exit_handler)();
            }

+            exit_handlers->pop_front();
+        }
+
+        // If TlsSetValue fails, we can't delete the list,
+        // since a second call to on_thread_exit will try
+        // to access it.
+
+        if( TlsSetValue( tls_key, 0 ) )
+        {
            delete exit_handlers;
-            exit_handlers = 0;
        }
    }
+}

 #endif //defined(BOOST_HAS_WINTHREADS)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -40,6 +40,6 @@ 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_read_write_mutex.cpp ]
    ;
 }
--- a/test/test_read_write_mutex.cpp
+++ b/test/test_read_write_mutex.cpp
@@ -0,0 +1,786 @@
+// 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/read_write_mutex.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
+#define TS_CHECK(pred) \
+    do { if (!(pred)) BOOST_ERROR (#pred); } while (0)
+#define TS_CHECK_MSG(pred, msg) \
+    do { if (!(pred)) BOOST_ERROR (msg); } while (0)
+
+namespace {
+
+int shared_val = 0;
+
+boost::xtime xsecs(int secs)
+{
+    //Create an xtime that is secs seconds from now
+    boost::xtime ret;
+    TS_CHECK (boost::TIME_UTC == boost::xtime_get(&ret, boost::TIME_UTC));
+    ret.sec += secs;
+    return ret;
+}
+
+#define MESSAGE "w1=" << w1.value_ << ", w2=" << w2.value_ << ", r1=" << r1.value_ << ", r2=" << r2.value_
+
+template <typename RW>
+class thread_adapter
+{
+public:
+
+    thread_adapter(
+        void (*func)(void*, RW&),
+        void* param1,
+        RW &param2
+        )
+        : func_(func)
+        , param1_(param1)
+        , param2_(param2)
+    {}
+
+    void operator()() const
+    {
+        func_(param1_, param2_);
+    }
+
+private:
+
+    void (*func_)(void*, RW&);
+    void* param1_;
+    RW& param2_;
+};
+
+const int k_data_init = -1;
+
+template <typename RW>
+struct data
+{
+    data(
+        int id,
+        RW& m,
+        int wait_for_lock_secs,
+        int sleep_with_lock_secs,
+        bool demote_after_write = false
+        )
+        : id_(id)
+        , wait_for_lock_secs_(wait_for_lock_secs)
+        , sleep_with_lock_secs_(sleep_with_lock_secs)
+        , test_promotion_and_demotion_(demote_after_write)
+        , value_(k_data_init)
+        , rw_(m)
+    {}
+
+    int id_;
+    int wait_for_lock_secs_;
+    int sleep_with_lock_secs_;
+    bool test_promotion_and_demotion_;
+    int value_;
+
+    RW& rw_;
+};
+
+template<typename RW>
+void plain_writer(void* arg, RW& rw)
+{
+    try
+    {
+        data<RW>* pdata = (data<RW>*) arg;
+        TS_CHECK_MSG(pdata->wait_for_lock_secs_ == 0, "pdata->wait_for_lock_secs_: " << pdata->wait_for_lock_secs_);
+
+        typename RW::scoped_read_write_lock l(
+            rw, 
+            pdata->test_promotion_and_demotion_ 
+                ? boost::read_write_lock_state::read_locked 
+                : boost::read_write_lock_state::write_locked
+            );
+
+        bool succeeded = true;
+
+        if (pdata->test_promotion_and_demotion_)
+        {
+            try
+            {
+                l.promote();
+            }
+            catch(const boost::lock_error&)
+            {
+                succeeded = false;
+            }
+        }
+
+        if (succeeded)
+        {
+            if (pdata->sleep_with_lock_secs_ > 0)
+                boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
+
+            shared_val += 10;
+
+            if (pdata->test_promotion_and_demotion_)
+                l.demote();
+
+            pdata->value_ = shared_val;
+        }
+    }
+    catch(...)
+    {
+        TS_CHECK_MSG(false, "plain_writer() exception!");
+        throw;
+    }
+}
+
+template<typename RW>
+void plain_reader(void* arg, RW& rw)
+{
+    try
+    {
+        data<RW>* pdata = (data<RW>*)arg;
+        TS_CHECK(!pdata->test_promotion_and_demotion_);
+        TS_CHECK_MSG(pdata->wait_for_lock_secs_ == 0, "pdata->wait_for_lock_secs_: " << pdata->wait_for_lock_secs_);
+
+        typename RW::scoped_read_write_lock l(rw, boost::read_write_lock_state::read_locked);
+
+        if (pdata->sleep_with_lock_secs_ > 0)
+            boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
+
+        pdata->value_ = shared_val;
+    }
+    catch(...)
+    {
+        TS_CHECK_MSG(false, "plain_reader() exception!");
+        throw;
+    }
+}
+
+template<typename RW>
+void try_writer(void* arg, RW& rw)
+{
+    try
+    {
+        data<RW>* pdata = (data<RW>*) arg;
+        TS_CHECK_MSG(pdata->wait_for_lock_secs_ == 0, "pdata->wait_for_lock_secs_: " << pdata->wait_for_lock_secs_);
+
+        typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::unlocked);
+
+        bool succeeded = false;
+
+        if (pdata->test_promotion_and_demotion_)
+            succeeded = l.try_read_lock() && l.try_promote();
+        else
+            succeeded = l.try_write_lock();
+
+        if (succeeded)
+        {
+            if (pdata->sleep_with_lock_secs_ > 0)
+                boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
+
+            shared_val += 10;
+
+            if (pdata->test_promotion_and_demotion_)
+                l.demote();
+
+            pdata->value_ = shared_val;
+        }
+    }
+    catch(...)
+    {
+        TS_CHECK_MSG(false, "try_writer() exception!");
+        throw;
+    }
+}
+
+template<typename RW>
+void try_reader(void*arg, RW& rw)
+{
+    try
+    {
+        data<RW>* pdata = (data<RW>*)arg;
+        TS_CHECK(!pdata->test_promotion_and_demotion_);
+        TS_CHECK_MSG(pdata->wait_for_lock_secs_ == 0, "pdata->wait_for_lock_secs_: " << pdata->wait_for_lock_secs_);
+
+        typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::unlocked);
+
+        if (l.try_read_lock())
+        {
+            if (pdata->sleep_with_lock_secs_ > 0)
+                boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
+
+            pdata->value_ = shared_val;
+        }
+    }
+    catch(...)
+    {
+        TS_CHECK_MSG(false, "try_reader() exception!");
+        throw;
+    }
+}
+
+template<typename RW>
+void timed_writer(void* arg, RW& rw)
+{
+    try
+    {
+        data<RW>* pdata = (data<RW>*)arg;
+
+        typename RW::scoped_timed_read_write_lock l(rw, boost::read_write_lock_state::unlocked);
+
+        bool succeeded = false;
+
+        boost::xtime xt = xsecs(pdata->wait_for_lock_secs_);
+        if (pdata->test_promotion_and_demotion_)
+            succeeded = l.timed_read_lock(xt) && l.timed_promote(xt);
+        else
+            succeeded = l.timed_write_lock(xt);
+
+        if (succeeded)
+        {
+            if (pdata->sleep_with_lock_secs_ > 0)
+                boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
+
+            shared_val += 10;
+
+            if (pdata->test_promotion_and_demotion_)
+                l.demote();
+
+            pdata->value_ = shared_val;
+        }
+    }
+    catch(...)
+    {
+        TS_CHECK_MSG(false, "timed_writer() exception!");
+        throw;
+    }
+}
+
+template<typename RW>
+void timed_reader(void* arg, RW& rw)
+{
+    try
+    {
+        data<RW>* pdata = (data<RW>*)arg;
+        TS_CHECK(!pdata->test_promotion_and_demotion_);
+
+        typename RW::scoped_timed_read_write_lock l(rw,boost::read_write_lock_state::unlocked);
+
+        boost::xtime xt = xsecs(pdata->wait_for_lock_secs_);
+        if (l.timed_read_lock(xt))
+        {
+            if (pdata->sleep_with_lock_secs_ > 0)
+                boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
+
+            pdata->value_ = shared_val;
+        }
+    }
+    catch(...)
+    {
+        TS_CHECK_MSG(false, "timed_reader() exception!");
+        throw;
+    }
+}
+
+template<typename RW>
+void clear_data(data<RW>& data1, data<RW>& data2, data<RW>& data3, data<RW>& data4)
+{
+    shared_val = 0;
+    data1.value_ = k_data_init;
+    data2.value_ = k_data_init;
+    data3.value_ = k_data_init;
+    data4.value_ = k_data_init;
+}
+
+bool shared_test_writelocked = false;
+bool shared_test_readlocked = false;
+bool shared_test_unlocked = false;
+
+template<typename RW>
+void run_try_tests(void* arg, RW& rw)
+{
+    try
+    {
+        TS_CHECK(shared_test_writelocked || shared_test_readlocked || shared_test_unlocked);
+
+        typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::unlocked);
+
+        if (shared_test_writelocked)
+        {
+            //Verify that write lock blocks other write locks
+            TS_CHECK(!l.try_write_lock());
+
+            //Verify that write lock blocks read locks
+            TS_CHECK(!l.try_read_lock());
+        }
+        else if (shared_test_readlocked)
+        {
+            //Verify that read lock blocks write locks
+            TS_CHECK(!l.try_write_lock());
+
+            //Verify that read lock does not block other read locks
+            TS_CHECK(l.try_read_lock());
+
+            //Verify that read lock blocks promotion
+            TS_CHECK(!l.try_promote());
+        }
+        else if (shared_test_unlocked)
+        {
+            //Verify that unlocked does not blocks write locks
+            TS_CHECK(l.try_write_lock());
+
+            //Verify that unlocked does not block demotion
+            TS_CHECK(l.try_demote());
+
+            l.unlock();
+
+            //Verify that unlocked does not block read locks
+            TS_CHECK(l.try_read_lock());
+
+            //Verify that unlocked does not block promotion
+            TS_CHECK(l.try_promote());
+            
+            l.unlock();
+        }
+    }
+    catch(...)
+    {
+        TS_CHECK_MSG(false, "run_try_tests() exception!");
+        throw;
+    }
+}
+
+template<typename RW>
+void test_plain_read_write_mutex(RW& rw, bool test_promotion_and_demotion)
+{
+    //Verify that a write lock prevents both readers and writers from obtaining a lock
+    {
+        shared_val = 0;
+        data<RW> r1(1, rw, 0, 0);
+        data<RW> r2(2, rw, 0, 0);
+        data<RW> w1(3, rw, 0, 0);
+        data<RW> w2(4, rw, 0, 0);
+
+        //Write-lock the mutex and queue up other readers and writers
+
+        typename RW::scoped_read_write_lock l(rw, boost::read_write_lock_state::write_locked);
+
+        boost::thread tr1(thread_adapter<RW>(plain_reader, &r1, rw));
+        boost::thread tr2(thread_adapter<RW>(plain_reader, &r2, rw));
+        boost::thread tw1(thread_adapter<RW>(plain_writer, &w1, rw));
+        boost::thread tw2(thread_adapter<RW>(plain_writer, &w2, rw));
+
+        boost::thread::sleep(xsecs(1));
+
+        //At this point, neither queued readers nor queued writers should have obtained access
+
+        TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+        TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+        TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
+        TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
+
+        if (test_promotion_and_demotion)
+        {
+            l.demote();
+            boost::thread::sleep(xsecs(1));
+            //:boost::thread tr3(thread_adapter<RW>(plain_reader, &r3, rw));
+
+            if (rw.policy() == boost::read_write_scheduling_policy::writer_priority)
+            {
+                //Expected result:
+                //Since writers have priority, demotion doesn't release any readers.
+                TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
+            }
+            else if (rw.policy() == boost::read_write_scheduling_policy::reader_priority)
+            {
+                //Expected result:
+                //Since readers have priority, demotion releases all readers.
+                TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
+            }
+            else if (rw.policy() == boost::read_write_scheduling_policy::alternating_many_reads)
+            {
+                //Expected result:
+                //Since readers can be released many at a time, demotion releases all queued readers.
+                TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
+                //:TS_CHECK_MSG(r3.value_ == k_data_init, MESSAGE);
+            }
+            else if (rw.policy() == boost::read_write_scheduling_policy::alternating_single_read)
+            {
+                //Expected result:
+                //Since readers can be released only one at a time, demotion releases one queued reader.
+                TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == k_data_init || r1.value_ == 0, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == k_data_init || r2.value_ == 0, MESSAGE);
+                TS_CHECK_MSG(r1.value_ != r2.value_, MESSAGE);
+            }
+        }
+        
+        l.unlock();
+
+        tr2.join();
+        tr1.join();
+        tw2.join();
+        tw1.join();
+
+        if (rw.policy() == boost::read_write_scheduling_policy::writer_priority)
+        {
+            if (!test_promotion_and_demotion)
+            {
+                //Expected result: 
+                //1) either w1 or w2 obtains and releases the lock
+                //2) the other of w1 and w2 obtains and releases the lock
+                //3) r1 and r2 obtain and release the lock "simultaneously"
+                TS_CHECK_MSG(w1.value_ == 10 || w1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == 10 || w2.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 20, MESSAGE);
+            }
+            else
+            {
+                //Expected result: 
+                //The same, except that either w1 or w2 (but not both) may
+                //fail to promote to a write lock,
+                //and r1, r2, or both may "sneak in" ahead of w1 and/or w2
+                //by obtaining a read lock before w1 or w2 can promote
+                //their initial read lock to a write lock.
+                TS_CHECK_MSG(w1.value_ == k_data_init || w1.value_ == 10 || w1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == k_data_init || w2.value_ == 10 || w2.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == k_data_init || r1.value_ == 10 || r1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == k_data_init || r2.value_ == 10 || r2.value_ == 20, MESSAGE);
+            }
+        }
+        else if (rw.policy() == boost::read_write_scheduling_policy::reader_priority)
+        {
+            if (!test_promotion_and_demotion)
+            {
+                //Expected result: 
+                //1) r1 and r2 obtain and release the lock "simultaneously"
+                //2) either w1 or w2 obtains and releases the lock
+                //3) the other of w1 and w2 obtains and releases the lock
+                TS_CHECK_MSG(w1.value_ == 10 || w1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == 10 || w2.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
+            }
+            else
+            {
+                //Expected result: 
+                //The same, except that either w1 or w2 (but not both) may
+                //fail to promote to a write lock.
+                TS_CHECK_MSG(w1.value_ == k_data_init || w1.value_ == 10 || w1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == k_data_init || w2.value_ == 10 || w2.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
+            }
+        }
+        else if (rw.policy() == boost::read_write_scheduling_policy::alternating_many_reads)
+        {
+            if (!test_promotion_and_demotion)
+            {
+                //Expected result: 
+                //1) r1 and r2 obtain and release the lock "simultaneously"
+                //2) either w1 or w2 obtains and releases the lock
+                //3) the other of w1 and w2 obtains and releases the lock
+                TS_CHECK_MSG(w1.value_ == 10 || w1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == 10 || w2.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
+            }
+            else
+            {
+                //Expected result: 
+                //The same, except that either w1 or w2 (but not both) may
+                //fail to promote to a write lock.
+                TS_CHECK_MSG(w1.value_ == k_data_init || w1.value_ == 10 || w1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == k_data_init || w2.value_ == 10 || w2.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
+            }
+        }
+        else if (rw.policy() == boost::read_write_scheduling_policy::alternating_single_read)
+        {
+            if (!test_promotion_and_demotion)
+            {
+                //Expected result:
+                //1) either r1 or r2 obtains and releases the lock
+                //2) either w1 or w2 obtains and releases the lock
+                //3) the other of r1 and r2 obtains and releases the lock
+                //4) the other of w1 and w2 obtains and release the lock
+                TS_CHECK_MSG(w1.value_ == 10 || w1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == 10 || w2.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 0 || r1.value_ == 10, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 0 || r2.value_ == 10, MESSAGE);
+                TS_CHECK_MSG(r1.value_ != r2.value_, MESSAGE);
+            }
+            else
+            {
+                //Expected result:
+                //Since w1 and w2 start as read locks, r1, r2, w1, and w2 
+                //obtain read locks "simultaneously". Each of w1 and w2, 
+                //after it obtain a read lock, attempts to promote to a
+                //write lock; this attempt fails if the other has
+                //already done so and currently holds the write lock;
+                //otherwise it will succeed as soon as any other 
+                //read locks have been released.
+                //In other words, any ordering is possible, and either
+                //w1 or w2 (but not both) may fail to obtain the lock
+                //altogether.
+                TS_CHECK_MSG(w1.value_ == k_data_init || w1.value_ == 10 || w1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w2.value_ == k_data_init || w2.value_ == 10 || w2.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
+                TS_CHECK_MSG(r1.value_ == 0 || r1.value_ == 10 || r1.value_ == 20, MESSAGE);
+                TS_CHECK_MSG(r2.value_ == 0 || r2.value_ == 10 || r2.value_ == 20, MESSAGE);
+            }
+        }
+    }
+
+    //Verify that a read lock prevents readers but not writers from obtaining a lock
+    {
+        shared_val = 0;
+        data<RW> r1(1, rw, 0, 0);
+        data<RW> r2(2, rw, 0, 0);
+        data<RW> w1(3, rw, 0, 0);
+        data<RW> w2(4, rw, 0, 0);
+
+        //Read-lock the mutex and queue up other readers and writers
+
+        typename RW::scoped_read_write_lock l(rw, boost::read_write_lock_state::read_locked);
+
+        boost::thread tr1(thread_adapter<RW>(plain_reader, &r1, rw));
+        boost::thread tr2(thread_adapter<RW>(plain_reader, &r2, rw));
+
+        boost::thread::sleep(xsecs(1));
+
+        boost::thread tw1(thread_adapter<RW>(plain_writer, &w1, rw));
+        boost::thread tw2(thread_adapter<RW>(plain_writer, &w2, rw));
+
+        boost::thread::sleep(xsecs(1));
+
+        //Expected result: all readers passed through before the writers entered
+        TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+        TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+        TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
+        TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
+
+        if (test_promotion_and_demotion)
+        {
+            l.promote();
+        }
+        
+        l.unlock();
+
+        tr2.join();
+        tr1.join();
+        tw2.join();
+        tw1.join();
+    }
+
+    //Verify that a read lock prevents readers but not writers from obtaining a lock
+    {
+        shared_val = 0;
+        data<RW> r1(1, rw, 0, 0);
+        data<RW> r2(2, rw, 0, 0);
+        data<RW> w1(3, rw, 0, 0);
+        data<RW> w2(4, rw, 0, 0);
+
+        //Read-lock the mutex and queue up other readers and writers
+
+        typename RW::scoped_read_write_lock l(rw, boost::read_write_lock_state::read_locked);
+
+        boost::thread tw1(thread_adapter<RW>(plain_writer, &w1, rw));
+        boost::thread tw2(thread_adapter<RW>(plain_writer, &w2, rw));
+
+        boost::thread::sleep(xsecs(1));
+
+        boost::thread tr1(thread_adapter<RW>(plain_reader, &r1, rw));
+        boost::thread tr2(thread_adapter<RW>(plain_reader, &r2, rw));
+
+        boost::thread::sleep(xsecs(1));
+
+        if (rw.policy() == boost::read_write_scheduling_policy::writer_priority)
+        {
+            //Expected result: 
+            //Writers have priority, so no readers have been released
+            TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
+        }
+        else if (rw.policy() == boost::read_write_scheduling_policy::reader_priority)
+        {
+            //Expected result: 
+            //Readers have priority, so all readers have been released
+            TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
+            TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
+        }
+        else if (rw.policy() == boost::read_write_scheduling_policy::alternating_many_reads)
+        {
+            //Expected result: 
+            //It's the writers' turn, so no readers have been released
+            TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
+        }
+        else if (rw.policy() == boost::read_write_scheduling_policy::alternating_single_read)
+        {
+            //Expected result: 
+            //It's the writers' turn, so no readers have been released
+            TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
+            TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
+        }
+
+        if (test_promotion_and_demotion)
+        {
+            l.promote();
+        }
+        
+        l.unlock();
+
+        tr2.join();
+        tr1.join();
+        tw2.join();
+        tw1.join();
+    }
+}
+
+template<typename RW>
+void test_try_read_write_mutex(RW& rw, bool test_promotion_and_demotion)
+{
+    //Repeat the plain tests with the try lock.
+    //This is important to verify that try locks are proper
+    //read_write_mutexes as well.
+
+    test_plain_read_write_mutex(rw, test_promotion_and_demotion);
+
+    //Verify try_* operations with write-locked mutex
+    {
+        typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::write_locked);
+
+        shared_test_writelocked = true;
+        shared_test_readlocked = false;
+        shared_test_unlocked = false;
+        
+        boost::thread test_thread(thread_adapter<RW>(run_try_tests, NULL, rw));
+        test_thread.join();
+    }
+
+    //Verify try_* operations with read-locked mutex
+    {
+        typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::read_locked);
+        
+        shared_test_writelocked = false;
+        shared_test_readlocked = true;
+        shared_test_unlocked = false;
+        
+        boost::thread test_thread(thread_adapter<RW>(run_try_tests, NULL, rw));
+        test_thread.join();
+    }
+
+    //Verify try_* operations with unlocked mutex
+    {
+        shared_test_writelocked = false;
+        shared_test_readlocked = false;
+        shared_test_unlocked = true;
+        
+        boost::thread test_thread(thread_adapter<RW>(run_try_tests, NULL, rw));
+        test_thread.join();
+    }
+}
+
+template<typename RW>
+void test_timed_read_write_mutex(RW& rw, bool test_promotion_and_demotion)
+{
+    //Repeat the try tests with the timed lock.
+    //This is important to verify that timed locks are proper
+    //try locks as well.
+
+    test_try_read_write_mutex(rw, test_promotion_and_demotion);
+
+    //:More tests here
+}
+
+} // namespace
+
+void do_test_read_write_mutex(bool test_promotion_and_demotion)
+{
+    //Run every test for each scheduling policy
+
+    for(int i = (int) boost::read_write_scheduling_policy::writer_priority;
+        i <= (int) boost::read_write_scheduling_policy::alternating_single_read;
+        i++)
+    {
+        std::cout << "plain test, sp=" << i 
+            << (test_promotion_and_demotion ? " with promotion & demotion" : " without promotion & demotion") 
+            << "\n";
+        std::cout.flush();
+
+        {
+            boost::read_write_mutex plain_rw(static_cast<boost::read_write_scheduling_policy::read_write_scheduling_policy_enum>(i));
+            test_plain_read_write_mutex(plain_rw, test_promotion_and_demotion);
+        }
+
+        std::cout << "try test, sp=" << i 
+            << (test_promotion_and_demotion ? " with promotion & demotion" : " without promotion & demotion")
+            << "\n";
+        std::cout.flush();
+
+        {
+            boost::try_read_write_mutex try_rw(static_cast<boost::read_write_scheduling_policy::read_write_scheduling_policy_enum>(i));
+            test_try_read_write_mutex(try_rw, test_promotion_and_demotion);
+        }
+
+        std::cout << "timed test, sp=" << i 
+            << (test_promotion_and_demotion ? " with promotion & demotion" : " without promotion & demotion") 
+            << "\n";
+        std::cout.flush();
+
+        {
+            boost::timed_read_write_mutex timed_rw(static_cast<boost::read_write_scheduling_policy::read_write_scheduling_policy_enum>(i));
+            test_timed_read_write_mutex(timed_rw, test_promotion_and_demotion);
+        }
+    }
+}
+
+void test_read_write_mutex()
+{
+    do_test_read_write_mutex(false);
+    do_test_read_write_mutex(true);
+}
+
+boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Threads: read_write_mutex test suite");
+
+    test->add(BOOST_TEST_CASE(&test_read_write_mutex));
+
+    return test;
+}
--- a/test/test_tss.cpp
+++ b/test/test_tss.cpp
@@ -144,11 +144,12 @@ void do_test_tss()
            << "\n";
        std::cout.flush();

-        // The following is not really an error. TSS cleanup support still is available for boost threads.
-        // Also this usually will be triggered only when bound to the static version of thread lib.
-        // 2006-10-02 Roland Schwarz
+        // The following is not really an error. TSS cleanup support still is available
+        // for threads, launched via the boost API. Also this usually will be triggered
+        // only when bound to the static version of the thread lib.
+        // 2006-10-15 Roland Schwarz
        //BOOST_CHECK_EQUAL(tss_instances, 0);
-        BOOST_CHECK_MESSAGE(tss_instances == 0, "Support of automatic tss cleanup for native threading API not available");
+        BOOST_CHECK_MESSAGE(tss_instances ==0, "Support of automatic tss cleanup for native threading API not available");
        BOOST_CHECK_EQUAL(tss_total, 5);
    #endif
 }
--- a/test/util.inl
+++ b/test/util.inl
@@ -16,8 +16,6 @@
 #   define DEFAULT_EXECUTION_MONITOR_TYPE execution_monitor::use_condition
 #endif

-// boostinspect:nounnamed
-
 namespace
 {
 inline boost::xtime delay(int secs, int msecs=0, int nsecs=0)
--- a/tutorial/Jamfile
+++ b/tutorial/Jamfile
@@ -0,0 +1,34 @@
+# 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)
+#
+# Boost.Threads tutorial Jamfile
+#
+# Additional configuration variables used:
+#   1. PTW32 may be used on Win32 platforms to specify that the pthreads-win32
+#      library should be used instead of "native" threads. This feature is
+#      mostly used for testing and it's generally recommended you use the
+#      native threading libraries instead. PTW32 should be set to be a list
+#      of two strings, the first specifying the installation path of the
+#      pthreads-win32 library and the second specifying which library
+#      variant to link against (see the pthreads-win32 documentation).
+#      Example: jam -sPTW32="c:\pthreads-win32 pthreadVCE.lib"
+
+project 
+    : requirements <library>/boost/thread//boost_thread
+	<threading>multi 
+    ;
+
+exe helloworld : helloworld.cpp ;
+exe helloworld2 : helloworld2.cpp ;
+exe helloworld3 : helloworld3.cpp ;
+exe helloworld4 : helloworld4.cpp ;
+exe factorial : factorial.cpp ;
+exe factorial2 : factorial2.cpp ;
+exe factorial3 : factorial3.cpp ;
+exe counter : counter.cpp ;
+exe bounded_buffer : bounded_buffer.cpp ;
+exe once : once.cpp ;
+
Author	SHA1	Message	Date
Ronald Garcia	35b8104a7c	Created a branch from trunk [SVN r38959]	2007-08-26 05:34:35 +00:00
Vladimir Prus	a8daedac5e	Revive V1 Jamfile to please asio [SVN r38837]	2007-08-22 12:40:34 +00:00
Vladimir Prus	5fa26fb3ac	Update to V2 [SVN r38531]	2007-08-08 19:47:16 +00:00
Vladimir Prus	ea3e297175	Remove V1 Jamfiles [SVN r38516]	2007-08-08 19:02:26 +00:00
Rene Rivera	a11bd6ebd9	Put in the build support for using the doxproc, Python based, Doxygen to BoostBook translator. [SVN r37457]	2007-04-17 04:44:59 +00:00
Roland Schwarz	9889bf50a2	FAQ Entry: Passing parameters during thread creation. [SVN r36922]	2007-02-11 13:52:28 +00:00
Roland Schwarz	d75fb2deda	Applying long outstanding patch. See:http://thread.gmane.org/gmane.comp.lib.boost.devel/118863/focus=118912 [SVN r36920]	2007-02-11 12:00:38 +00:00
Roland Schwarz	6355a5b28d	Changes for WINCE [SVN r36484]	2006-12-22 09:40:17 +00:00
Roland Schwarz	595bbee41e	Converted back to CHECK since warnings not showing up in regression tables. [SVN r36386]	2006-12-14 17:49:21 +00:00
Roland Schwarz	cb3f3a1f64	Fixed the missing tss_nul file for testing. [SVN r36331]	2006-12-11 19:22:40 +00:00
Vladimir Prus	0e44838905	Allow building of shared versions of some Boost.Test libraries. Adjust tests to use always use static linking to Boost.Test, since linking to the shared version requires test changes. Patch from Juergen Hunold. [SVN r35989]	2006-11-10 19:09:56 +00:00
Roland Schwarz	64cd268fc7	Get rid of dll import warnings for nocopyable classes [SVN r35796]	2006-10-30 19:27:51 +00:00
Roland Schwarz	f048dd81f2	Merged changes from RC_1_34_0 [SVN r35616]	2006-10-15 10:27:28 +00:00
Roland Schwarz	5746f2214c	cosmetics [SVN r35615]	2006-10-15 10:10:47 +00:00
Roland Schwarz	099af669d4	Made fail of cleanup test for native API a warning. [SVN r35614]	2006-10-15 10:03:35 +00:00
Roland Schwarz	79cac706a7	Unified spelling of thread library in documentation. (singular) [SVN r35590]	2006-10-13 16:48:50 +00:00
Roland Schwarz	df229074ac	Made size() a constant member function. [SVN r35589]	2006-10-13 16:41:51 +00:00
Anthony Williams	191c27e856	Added missing #include [SVN r35577]	2006-10-12 16:30:27 +00:00
Anthony Williams	e5ee01b43c	Remove spurious #endif [SVN r35576]	2006-10-12 14:52:43 +00:00
Anthony Williams	c46b040f6f	Applied some of David Deakins' patches for WinCE [SVN r35532]	2006-10-10 07:34:48 +00:00
Roland Schwarz	72e4794f5b	Removed the "intentional memory leak" of the TSS implementation [SVN r35426]	2006-09-29 19:24:19 +00:00
Anthony Williams	c30b65a0ea	Added #ifdef _WIN64 around a direct call to InterlockedCompareExchange rather than the existing call through ice_wrapper. The platform SDK library for Win64 doesn't include a library version of InterlockedCompareExchange which the ice_wrapper code requires. [SVN r35340]	2006-09-26 16:31:41 +00:00
Hartmut Kaiser	1cb08ff60c	Changed Boost.Thread to use the Boost license. [SVN r35115]	2006-09-14 23:02:29 +00:00
Anthony Williams	d3d7fd9317	Added call to TlsFree [SVN r34843]	2006-08-07 16:34:54 +00:00
Peter Dimov	acf0f97663	Simplification, avoids a false leak report [SVN r34706]	2006-07-24 19:00:30 +00:00
Peter Dimov	34bd87cea7	Moved the on_thread_exit call to a destructor [SVN r34469]	2006-07-06 19:47:12 +00:00
Peter Dimov	228f11262e	Removed the infamous catch(...) [SVN r34467]	2006-07-06 13:45:13 +00:00
Anthony Williams	9683e0f1cc	Added patch from http://lists.boost.org/Archives/boost/2005/05/86395.php to fix bug https://sourceforge.net/tracker/index.php?func=detail&aid=1424965&group_id=7586&atid=107586 [SVN r33802]	2006-04-25 10:06:38 +00:00
Vladimir Prus	674ae6d571	Remove declaration of 'pthread'. It was hack [SVN r33596]	2006-04-07 14:00:27 +00:00
Vladimir Prus	690d44e2e6	Setup usage requirements for dllimport/dllexport. [SVN r33431]	2006-03-22 08:49:42 +00:00