Created a branch from trunk

[SVN r38959]

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

build/Jamfile.v2

@@ -20,7 +20,7 @@ CPP_SOURCES =
         mutex
         once
         recursive_mutex
-#        read_write_mutex
+        read_write_mutex
         thread
         tss_hooks
         tss_dll

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

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>
 

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>

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

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

doc/read_write_mutex-ref.xml

@@ -37,16 +37,6 @@
 		<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>
@@ -170,16 +160,6 @@
 		<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>
@@ -322,16 +302,6 @@
 		<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>

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"/>

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

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>

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)

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

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
 {

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.

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;

include/boost/thread/tss.hpp

@@ -45,7 +45,6 @@ public:
             throw boost::thread_resource_error();
         }
     }
-
     ~tss();
     void* get() const;
     void set(void* value);

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;

src/mutex.inl

@@ -24,15 +24,7 @@ void init_TryEnterCriticalSection()
         version_info.dwMajorVersion >= 4)
     {
         if (HMODULE kernel_module = GetModuleHandle(TEXT("KERNEL32.DLL")))
-        {
-            g_TryEnterCriticalSection = reinterpret_cast<TryEnterCriticalSection_type>(
-#if defined(BOOST_NO_ANSI_APIS)
-                GetProcAddressW(kernel_module, L"TryEnterCriticalSection")
-#else
-                GetProcAddress(kernel_module, "TryEnterCriticalSection")
-#endif        
-                );
-        }
+            g_TryEnterCriticalSection = reinterpret_cast<TryEnterCriticalSection_type>(GetProcAddress(kernel_module, TEXT("TryEnterCriticalSection")));
     }
 }
 
@@ -70,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

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;

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)

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();
 }

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 {

src/tss.cpp

@@ -31,7 +31,7 @@ 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=TLS_OUT_OF_INDEXES;
+    DWORD tss_data_native_key;
 #elif defined(BOOST_HAS_PTHREADS)
     pthread_key_t tss_data_native_key;
 #elif defined(BOOST_HAS_MPTASKS)
@@ -60,7 +60,6 @@ void tss_data_dec_use(boost::mutex::scoped_lock& lk)
         tss_data_mutex = 0;
 #if defined(BOOST_HAS_WINTHREADS)
         TlsFree(tss_data_native_key);
-        tss_data_native_key=TLS_OUT_OF_INDEXES;
 #elif defined(BOOST_HAS_PTHREADS)
         pthread_key_delete(tss_data_native_key);
 #elif defined(BOOST_HAS_MPTASKS)
@@ -79,17 +78,13 @@ extern "C" void cleanup_slots(void* p)
         (*(*tss_data_cleanup_handlers)[i])((*slots)[i]);
         (*slots)[i] = 0;
     }
-#if defined(BOOST_HAS_WINTHREADS)
-    TlsSetValue(tss_data_native_key,0);
-#endif
     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<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)
@@ -101,8 +96,9 @@ void init_tss_data()
 
     //Allocate tls slot
     tss_data_native_key = TlsAlloc();
-    if (tss_data_native_key == TLS_OUT_OF_INDEXES)
+    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)

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)

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 ]
     ;
 }

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

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
 }

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)

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