This commit was manufactured by cvs2svn to create tag

'Version_1_34_0_beta'.

[SVN r37504]

build/Jamfile

@@ -1,122 +0,0 @@
-# Copyright (C) 2001-2003
-# William E. Kempf
-#
-#  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-#  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-# 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

@@ -1,65 +0,0 @@
-# Copyright (C) 2001-2003
-# William E. Kempf
-#
-#  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-#  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-# 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,6 +63,11 @@ 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,6 +5,7 @@
   %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)
 -->
@@ -25,38 +26,112 @@
 	</para>
 	<section id="thread.build.building">
 		<title>Building the &Boost.Thread; Libraries</title>
-		<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>
+        <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>
 	</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 -sTOOLS=<emphasis>toolset</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 --toolset=<emphasis>mytoolset</emphasis> test</programlisting>
 		</para>
 	</section>
 </section>

doc/concepts.xml

@@ -18,7 +18,17 @@
 	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>
+    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>
 
 	<section id="thread.concepts.mutexes">
 		<title>Mutexes</title>
@@ -739,13 +749,18 @@
 
 	<section id="thread.concepts.read-write-mutexes">
 	<title>Read/Write Mutexes</title>
-		<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>
+        <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>
 
-		<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,6 +2,7 @@
      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/reference.xml

@@ -17,6 +17,12 @@
   <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,7 +10,63 @@
 -->
 <section id="thread.release_notes" last-revision="$Date$">
 	<title>Release Notes</title>
-	<section id="thread.release_notes.boost_1_32_0">
+    <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">
 		<title>Boost 1.32.0</title>
 
 		<section id="thread.release_notes.boost_1_32_0.change_log.documentation">

doc/thread-ref.xml

@@ -264,20 +264,7 @@
 				<effects>Calls <code>join()</code> on each of the managed 
 				<classname>thread</classname> objects.</effects>
 			</method>
-        </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>
+		</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,6 +28,7 @@ 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,6 +29,7 @@ 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

@@ -11,6 +11,8 @@
 #ifndef BOOST_READ_WRITE_MUTEX_JDM030602_HPP
 #define BOOST_READ_WRITE_MUTEX_JDM030602_HPP
 
+#error Read Write Mutex is broken, do not include this header 
+
 #include <boost/thread/detail/config.hpp>
 
 #include <boost/utility.hpp>
@@ -53,7 +55,7 @@ struct read_write_mutex_impl
     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)
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(582))
     ~read_write_mutex_impl();
 #endif
 

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() const;
+        int size();
 
 private:
     std::list<thread*> m_threads;

include/boost/thread/tss.hpp

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

src/condition.cpp

@@ -27,6 +27,12 @@
 #   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 {
@@ -373,6 +379,20 @@ 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

@@ -62,10 +62,8 @@ inline void* new_critical_section()
 inline void* new_mutex(const char* name)
 {
 #if defined(BOOST_NO_ANSI_APIS)
-    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);
+    USES_CONVERSION;
+    HANDLE mutex = CreateMutexW(0, 0, A2CW(name));
 #else
     HANDLE mutex = CreateMutexA(0, 0, name);
 #endif

src/once.cpp

@@ -9,7 +9,6 @@
 #include <boost/detail/workaround.hpp>
 
 #include <boost/thread/once.hpp>
-#include <boost/thread/exceptions.hpp>
 #include <cstdio>
 #include <cassert>
 
@@ -19,7 +18,6 @@
       using std::size_t;
 #   endif
 #   include <windows.h>
-#   include "mutex.inl"
 #   if defined(BOOST_NO_STRINGSTREAM)
 #       include <strstream>
 
@@ -116,8 +114,11 @@ inline LONG ice_wrapper(LPVOID (__stdcall *ice)(LPVOID*, LPVOID, LPVOID),
 inline LONG compare_exchange(volatile LPLONG dest, LONG exch, LONG cmp)
 {
 #ifdef _WIN64
-    return InterlockedCompareExchange(dest, exch, cmp);
-#else
+    // Original patch from Anthony Williams.
+    // I (Roland Schwarz) am trying this for RC_1_34_0, since x64 regressions are
+    // currently not run on x64 platforms for HEAD
+    return InterlockedCompareExchange(dest, exch,cmp);
+#else    
     return ice_wrapper(&InterlockedCompareExchange, dest, exch, cmp);
 #endif
 }
@@ -139,7 +140,12 @@ void call_once(void (*func)(), once_flag& flag)
              << &flag 
              << std::ends;
         unfreezer unfreeze(strm);
-        HANDLE mutex=new_mutex(strm.str());
+#   if defined (BOOST_NO_ANSI_APIS)
+        USES_CONVERSION;
+        HANDLE mutex = CreateMutexW(NULL, FALSE, A2CW(strm.str()));
+#   else
+        HANDLE mutex = CreateMutexA(NULL, FALSE, strm.str());
+#   endif
 #else
 #   if defined (BOOST_NO_ANSI_APIS)
         std::wostringstream strm;

src/read_write_mutex.cpp

@@ -7,6 +7,9 @@
 /*
 PROBLEMS:
 
+The read write mutex currently is broken. Do not use it.
+The file is supplied just for reference.
+
 The algorithms are not exception safe. For instance, if conditon::wait()
 or another call throws an exception, the lock state and other state data
 are not appropriately adjusted.
@@ -374,7 +377,10 @@ read_write_mutex_impl<Mutex>::read_write_mutex_impl(read_write_scheduling_policy
     , m_readers_next(true) 
 {}
 
-#if !BOOST_WORKAROUND(__BORLANDC__, <= 0x564)
+// Borland requires base class destructors to be explicitly exported from DLL's
+// even if they're not explicitly called. As this only contains postconditions,
+// it's reasonably safe to comment it out - Nicola Musatti 5/5/2006
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(582))
 template<typename Mutex>
 read_write_mutex_impl<Mutex>::~read_write_mutex_impl()
 {

src/recursive_mutex.cpp

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

src/thread.cpp

@@ -89,18 +89,6 @@ 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" {
@@ -112,25 +100,22 @@ extern "C" {
         static OSStatus thread_proxy(void* param)
 #endif
     {
-//        try
-        {
-#if defined(BOOST_HAS_WINTHREADS)
-
-            on_thread_exit_guard guard;
-
-#endif
-
+        //try
+        //{
             thread_param* p = static_cast<thread_param*>(param);
             boost::function0<void> threadfunc = p->m_threadfunc;
             p->started();
             threadfunc();
-        }
-//        catch (...)
-//        {
-//#if defined(BOOST_HAS_WINTHREADS)
-//            on_thread_exit();
-//#endif
-//        }
+#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
@@ -378,7 +363,7 @@ void thread_group::join_all()
     }
 }
 
-int thread_group::size() const
+int thread_group::size()
 {
         return m_threads.size();
 }

src/timeconv.inl

@@ -3,6 +3,7 @@
 //
 //  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

@@ -84,7 +84,8 @@ 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)
@@ -98,7 +99,6 @@ 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)

src/tss_hooks.cpp

@@ -1,7 +1,5 @@
-// (C) Copyright Michael Glassford 2004.
-// Copyright (c) 2006 Peter Dimov
-// Copyright (c) 2006 Anthony Williams
-//
+// Copyright (C) 2004 Michael Glassford
+// Copyright (C) 2006 Roland Schwarz
 // 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)
@@ -10,152 +8,205 @@
 
 #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/once.hpp>
+    #include <boost/assert.hpp>
+//    #include <boost/thread/mutex.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
-{
-
-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 )
+    namespace
     {
-        return -1;
+        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;
     }
 
-    // Get the exit handlers list for the current thread from tls.
+    /*
+    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.
+    */
 
-    thread_exit_handlers* exit_handlers =
-        static_cast< thread_exit_handlers* >( TlsGetValue( tls_key ) );
-
-    if( exit_handlers == 0 )
+    extern "C" BOOST_THREAD_DECL int at_thread_exit(
+        thread_exit_handler exit_handler
+        )
     {
-        // No exit handlers list was created yet.
+        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.
 
         try
         {
-            // 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;
-            }
+            exit_handlers->push_front(exit_handler);
         }
-        catch( ... )
+        catch (...)
         {
             return -1;
         }
+
+        //Like the atexit() function, a result of zero
+        //indicates success.
+
+        return 0;
     }
 
-    // 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.
+    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);
 
-    try
-    {
-        exit_handlers->push_front( exit_handler );
-    }
-    catch( ... )
-    {
-        return -1;
+        BOOST_ASSERT(attached_thread_count == 0);
     }
 
-    // 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 )
+    extern "C" BOOST_THREAD_DECL void on_process_exit(void)
     {
-        TlsFree(tls_key);
-    }
-}
+        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+//        boost::mutex::scoped_lock lock(*threadmon_mutex);
+        CScopedCSLock lock(&threadmon_mutex);
 
-extern "C" BOOST_THREAD_DECL void on_thread_enter()
-{
-}
+        BOOST_ASSERT(attached_thread_count == 0);
 
-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 );
+        //Free the tls slot if one was allocated.
 
-    // 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() )
+        if (tls_key != invalid_tls_key)
         {
-            if( thread_exit_handler exit_handler = *exit_handlers->begin() )
+            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())
             {
-                (*exit_handler)();
+                if (thread_exit_handler exit_handler = *exit_handlers->begin())
+                    (*exit_handler)();
+                exit_handlers->pop_front();
             }
 
-            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_tss.cpp

@@ -144,12 +144,11 @@ void do_test_tss()
             << "\n";
         std::cout.flush();
 
-        // 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
+        // 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
         //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,6 +16,8 @@
 #   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

@@ -1,34 +0,0 @@
-# Copyright (C) 2001-2003
-# William E. Kempf
-#
-#  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-#  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-# 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 ;
-