This commit was manufactured by cvs2svn to create branch

'python-v2-dev'. [SVN r14785]
Split up tests into seperate files and switched fully to unit test framework
2026-02-03 09:42:16 +00:00 · 2002-08-12 13:35:54 +00:00 · 2002-08-12 05:43:10 +00:00 · 2002-08-12 00:09:33 +00:00 · 2002-05-21 16:24:07 +00:00 · 2002-05-15 14:35:39 +00:00
98 changed files with 11969 additions and 0 deletions
--- a/build/.cvsignore
+++ b/build/.cvsignore
@@ -0,0 +1,2 @@
 bin*
 *.pdb
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -0,0 +1,70 @@
 #  (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell and
 #  distribute this software is granted provided this copyright notice appears
 #  in all copies. This software is provided "as is" without express or implied
 #  warranty, and with no claim as to its suitability for any purpose.
 #
 # Boost.Threads build Jamfile
 #
 # Declares the following targets:
 #   1. libboost_thread, a static link library.
 #      1a. On Win32 (when PTW32 is not defined), a dynamic link library
 #          boost_threadmon, which must be used in conjunction with
 #          libboost_thread. Note that this DLL *must* be used through static
 #          linking to the import library.  Dynamic loading will cause undefined
 #          behavior.
 # 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"
 # 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.
 SEARCH on <module@>threads.jam = $(SUBDIR) ;
 include <module@>threads.jam ;
 #######################
 # Conditionally declare the Boost.Threads dynamic link library boost_threadmon.
 if $(NT) && ! $(PTW32)
 {
    dll boost_threadmon
        : ../src/threadmon.cpp
        : <sysinclude>$(BOOST_ROOT)
          <threading>multi
        : debug release <runtime-link>static/dynamic
    ;
 }
 #######################
 # Declare the Boost.Threads static link library libboost_thread.
 # Base names of the source files for libboost_thread.
 CPP_SOURCES =
    condition mutex recursive_mutex thread tss xtime once exceptions ;
 lib boost_thread
    : ../src/$(CPP_SOURCES).cpp
    : <sysinclude>$(BOOST_ROOT)
      <threading>multi
      $(pthreads-win32)
    : debug release <runtime-link>static/dynamic
 ;
 #######################
 # Stage the generated targets.
 #stage bin-stage
 #    : <lib>boost_thread $(threadmon)
 #    : <tag><runtime-link-static>"s"
 #      <tag><debug>"d"
 #    : debug release <runtime-link>static/dynamic
 #;
--- a/build/threads.jam
+++ b/build/threads.jam
@@ -0,0 +1,23 @@
 # Do some OS-specific setup
 threadmon = ;
 pthreads-win32 = ;
 if $(NT)
 {
    if $(PTW32)
    {
        local install-path = $(PTW32[1]) ;
        local lib = $(PTW32[2]) ;
 		pthreads-win32 =
 		      <define>BOOST_HAS_PTHREADS
              <define>PtW32NoCatchWarn
              <include>$(install-path)/pre-built/include
              <library-file>$(install-path)/pre-built/lib/$(lib)
 		;
    }
    else
    {
        threadmon = <dll>../build/boost_threadmon ;
    }
 }
--- a/build/threads.mcp
+++ b/build/threads.mcp
--- a/doc/acknowledgments.html
+++ b/doc/acknowledgments.html
@@ -0,0 +1,69 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Acknowledgments</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Acknowledgments</h2>
    </td>
  </tr>
 </table>
 <hr>
 <p><a href="../../../people/william_kempf.htm">William E. Kempf</a> was the architect, 
  designer, and implementor of <b>Boost.Threads</b>.</p>
 <p>Mac OS Carbon implementation written by <a href="../../../people/mac_murrett.htm">Mac 
  Murrett</a>.</p>
 <p>Important contributions were also made by Jeremy Siek (lots of input on the 
  design and on the implementation), Alexander Terekhov (lots of input on the 
  Win32 implementation, especially in regards to boost::condition, as well as 
  a lot of explanation of POSIX behavior), Greg Colvin (lots of input on the design), 
  Paul Mclachlan, Thomas Matelich and Iain Hanson (for help in trying to get the 
  build to work on other platforms), and Kevin S. Van Horn (for several updates/corrections 
  to the documentation).</p>
 <p>The documentation was written by William E. Kempf. Beman Dawes provided additional 
  documentation material and editing.</p>
 <p>Discussions on the boost.org mailing list were essential in the development 
  of <b>Boost.Threads</b>. As of August 1, 2001, participants included Alan Griffiths, 
  Albrecht Fritzsche, Aleksey Gurtovoy, Alexander Terekhov, Andrew Green, Andy 
  Sawyer, Asger Alstrup Nielsen, Beman Dawes, Bill Klein, Bill Rutiser, Bill Wade, 
  Branko &Egrave;ibej, Brent Verner, Craig Henderson, Csaba Szepesvari, Dale Peakall, 
  Damian Dixon, Dan Nuffer, Darryl Green, Daryle Walker, David Abrahams, David 
  Allan Finch, Dejan Jelovic, Dietmar Kuehl, Doug Gregor, Douglas Gregor, Duncan 
  Harris, Ed Brey, Eric Swanson, Eugene Karpachov, Fabrice Truillot, Frank Gerlach, 
  Gary Powell, Gernot Neppert, Geurt Vos, Ghazi Ramadan, Greg Colvin, Gregory 
  Seidman, HYS, Iain Hanson, Ian Bruntlett, J Panzer, Jeff Garland, Jeff Paquette, 
  Jens Maurer, Jeremy Siek, Jesse Jones, Joe Gottman, John (EBo) David, John Bandela, 
  John Maddock, John Max Skaller, John Panzer, Jon Jagger , Karl Nelson, Kevlin 
  Henney, KG Chandrasekhar, Levente Farkas, Lie-Quan Lee, Lois Goldthwaite, Luis 
  Pedro Coelho, Marc Girod, Mark A. Borgerding, Mark Rodgers, Marshall Clow, Matthew 
  Austern, Matthew Hurd, Michael D. Crawford, Michael H. Cox , Mike Haller, Miki 
  Jovanovic, Nathan Myers, Paul Moore, Pavel Cisler, Peter Dimov, Petr Kocmid, 
  Philip Nash, Rainer Deyke, Reid Sweatman, Ross Smith, Scott McCaskill, Shalom 
  Reich , Steve Cleary, Steven Kirk, Thomas Holenstein, Thomas Matelich, Trevor 
  Perrin, Valentin Bonnard, Vesa Karvonen, Wayne Miller, and William Kempf.</p>
 <p>Apologies for anyone inadvertently missed.</p>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/bibliography.html
+++ b/doc/bibliography.html
@@ -0,0 +1,165 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Bibliography</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Bibliography</h2>
    </td>
  </tr>
 </table>
 <hr>
 <table summary="Bibliography" border="0" cellpadding="5" width="777">
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "Andrews-83">Andrews 83</a>]</b></td>
    <td width="645"> Gregory R. Andrews, Fred B. Schneider, <cite>Concepts and 
      Notations for Concurrent Programming</cite>, ACM Computing Surveys, Vol. 
      15, No. 1, March, 1983. <a href=
                    "http://www.acm.org/pubs/citations/journals/surveys/1983-15-1/p3-andrews/"> 
      http://www.acm.org/pubs/citations/journals/surveys/1983-15-1/p3-andrews/</a> 
      <p>Good general background reading. Includes descriptions of Path Expressions, 
        Message Passing, and Remote Procedure Call in addition to the basics.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "Boost">Boost</a>]</b></td>
    <td width="645"> The <cite>Boost</cite> worldwide web site. <a href=
                    "http://www.boost.org">http://www.boost.org</a> 
      <p>Boost.Threads is one of many Boost libraries. The Boost web site includes 
        a great deal of documentation and general information which applies to 
        all Boost libraries. Current copies of the libraries including documentation 
        and test programs may be downloaded from the web site.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "Brinch-Hansen-73">Brinch Hansen 73</a>]</b></td>
    <td width="645"> Per Brinch Hansen, <cite>Concurrent Programming Concepts</cite>, 
      ACM Computing Surveys, Vol. 5, No. 4, December, 1973. <a href=
                    "http://www.acm.org/pubs/articles/journals/surveys/1973-5-4/p223-hansen/p223-hansen.pdf"> 
      http://www.acm.org/pubs/articles/journals/surveys/1973-5-4/p223-hansen/</a> 
      <p>&quot;This paper describes the evolution of language features for multiprogramming 
        from event queues and semaphores to critical regions and monitors.&quot; 
        Includes analysis of why <i>events</i> are considered error-prone. Also 
        noteworthy because of an introductory quotation from Christopher Alexander; 
        Brinch Hansen was years ahead of others in recognizing pattern concepts 
        applied to software too.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>]<a name=
                "Butenhof-97">Butenhof 97</a>]</b></td>
    <td width="645"> 
      <p>David R. Butenhof, <cite>Programming with POSIX Threads</cite>, Addison-Wesley 
        1997, ISBN 0-201-63392-2 <a
                    href="http://cseng.aw.com/book/0,3828,0201633922,00.html"> 
        http://cseng.aw.com/book/0,3828,0201633922,00.html</a></p>
      <p>This is a very readable explanation of threads and how to use them. Many 
        of the insights given apply to all multithreaded programming, not just 
        POSIX Threads.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "Hoare-74">Hoare 74</a>]</b></td>
    <td width="645"> 
      <p>C.A.R Hoare, <cite>Monitors: An Operating System Structuring Concept</cite>, 
        Communications of the ACM, Vol. 17, No. 10. October 1974, pp. 549-557 
        <a href=
                    "http://www.acm.org/classics/feb96/"> http://www.acm.org/classics/feb96/</a></p>
      <p>Hoare and Brinch Hansen&#39;s work on Monitors is the basis for reliable 
        multithreading patterns. This is one of the most often referenced papers 
        in all of computer science, and with good reason.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "ISO-98">ISO 98</a>]</b></td>
    <td width="645"> 
      <p>ISO/IEC 14882:1998(E) <cite>Programming Language C++</cite> <a href="http://www.ansi.org"> 
        http://www.ansi.org</a></p>
      <p>This is the official C++ Standards document. Available from the ANSI 
        (American National Standards Institute) Electronic Standards Store.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "McDowell-89">McDowell 89</a>]</b></td>
    <td width="645"> Charles E McDowell, David P. Helmbold, <cite>Debugging Concurrent 
      Programs</cite>, ACM Computing Surveys, Vol. 21, No. 2, December, 1989. 
      <a href=
                    "http://www.acm.org/pubs/citations/journals/surveys/1989-21-4/p593-mcdowell/"> 
      http://www.acm.org/pubs/citations/journals/surveys/1989-21-4/p593-mcdowell/</a> 
      <p>Identifies many of the unique failure modes and debugging difficulties 
        associated with concurrent programs.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "Schmidt">Schmidt</a>]</b> </td>
    <td width="645"> 
      <p>Douglas C. Schmidt and Irfan Pyarali, <cite>Strategies for Implementing 
        POSIX Condition Variables on Win32</cite>, Department of Computer Science, 
        Washington University, St. Louis, Missouri. <a href=
                    "http://www.cs.wustl.edu/~schmidt/win32-cv-1.html"> http://www.cs.wustl.edu/~schmidt/win32-cv-1.html</a></p>
      <p>Rationale for understanding Boost.Threads condition variables. Note that 
        Alexander Terekhov found some bugs in the implementation given in this 
        article, so pthreads-win32 and Boost.Threads are even more complicated 
        yet.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "Schmidt-00">Schmidt 00</a>]</b> </td>
    <td width="645"> 
      <p>Douglas C. Schmidt, Michael Stal, Hans Rohnert and Frank Buschmann, <cite>Pattern-Oriented 
        Software Architecture Volume 2 - Patterns for Concurrent and Networked 
        Objects</cite>, Wiley 2000, ISBN 0-471-60695-2 <a href=
                    "http://www.wiley.com/Corporate/Website/Objects/Products/0,9049,104671,00.html"> 
        http://www.wiley.com/Corporate/Website/Objects/Products/0,9049,104671,00.html</a></p>
      <p>This is a very good explanation of how to apply several patterns useful 
        for concurrent programming. Among the patterns documented is the Monitor 
        Pattern mentioned frequently in the <b>Boost.Threads</b> documentation.</p>
    </td>
  </tr>
  <tr> 
    <td width="102" valign="top" align="left"><b>[<a name=
                "Stroustrup-00">Stroustrup 00</a>]</b></td>
    <td width="645"> Bjarne Stroustrup, <cite>The C++ Programming Language</cite>, 
      Special Edition, Addison-Wesley 2000, ISBN 0-201-70073-5 <a href=
                    "http://cseng.aw.com/book/0,3828,0201700735,00.html"> http://cseng.aw.com/book/0,3828,0201700735,00.html</a> 
      <p>The first book a C++ programmer should own. Note that the 3rd edition 
        (and subsequent editions like the Special Edition) has been rewritten 
        to cover the ISO standard language and library.</p>
    </td>
  </tr>
 </table>
 <p>Note: The URL&#39;s above are provided in plain text form so that they will 
  be visible on printed copies of this document.</p>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> and 
  Beman Dawes 2001-2002. All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/condition.html
+++ b/doc/condition.html
@@ -0,0 +1,294 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Header &lt;boost/thread/condition.hpp&gt;</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Header &lt;<a href="../../../boost/thread/condition.hpp">boost/thread/condition.hpp</a>&gt;</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#classes">Classes</a></dt>
  <dl class="page-index"> 
    <dt><a href="#class-condition">Class <code>condition</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-condition-synopsis">Class <code>condition</code> synopsis</a></dt>
      <dt><a href="#class-condition-ctors">Class <code>condition</code> constructors 
        and destructor</a></dt>
      <dt><a href="#class-condition-modifiers">Class <code>condition</code> modifier 
        functions</a></dt>
    </dl>
  </dl>
  <dt><a href="#examples">Example(s)</a></dt>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>Include the header &lt;<a href="../../../boost/thread/condition.hpp">boost/thread/condition.hpp</a>&gt; 
  to define the class condition.</p>
 <h2><a name="classes"></a>Classes</h2>
 <h3><a name="class-condition"></a>Class <code>condition</code></h3>
 <p>An object of class <code>condition</code> is a synchronization primitive used 
  to cause a thread to wait until a particular shared-data condition (or time) 
  is met. A <code>condition</code> object is always used in conjunction with a 
  mutex object (an object whose type is a model of <a href="mutex_concept.html">Mutex</a> 
  or one of its refinements). The mutex object must be locked prior to waiting 
  on the <code>condition</code>, which is verified by passing a lock object (an 
  object whose type is a model of <a href="lock_concept.html">Lock</a> or one 
  of its refinements) to the <code>condition</code> object&#39;s <code>wait</code> 
  functions. Upon blocking on the condition object, the thread unlocks the mutex 
  object. When the thread returns from a call to one of the condition object's 
  wait functions the mutex object is again locked. The tricky unlock/lock sequence 
  is performed automatically by the <code> condition</code> object&#39;s <code>wait</code> 
  functions.</p>
 <p>The <code>condition</code> type is often used to implement the <i> Monitor 
  Object</i> and other important patterns (see <a href="bibliography.html#Schmidt-00">[Schmidt 
  00]</a> and <a href="bibliography.html#Hoare-74">[Hoare 74]</a>). Monitors are 
  one of the most important patterns for creating reliable multithreaded programs.</p>
 <p>See <a href="definitions.html">Formal Definitions</a> for definitions of thread 
  states <a href="definitions.html#state"> blocked</a> and <a href="definitions.html#state">ready</a>. 
  Note that &quot;waiting&quot; is a synonym for blocked.</p>
 <h4><a name="class-condition-synopsis"></a>Class <code>condition</code> synopsis</h4>
 <pre>
 namespace boost
 {
    class condition : private <a href="../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
       // Class condition meets the <a href="overview.html#non-copyable">NonCopyable</a> requirement.
    {
    public:
        condition();
        ~condition();
        void notify_one();
        void notify_all();
        template &lt;typename <a href="lock_concept.html#Lock-concept">Lock</a>&gt;
            void wait(<a href="lock_concept.html#Lock-concept">Lock</a>&amp; lock);
        template &lt;typename <a href="lock_concept.html#Lock-concept">Lock</a>, typename <a href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>&gt;
            void wait(<a href="lock_concept.html#Lock-concept">Lock</a>&amp; lock, <a href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a> pred);
        template &lt;typename <a href="lock_concept.html#Lock-concept">Lock</a>&gt;
            bool timed_wait(<a href="lock_concept.html#Lock-concept">Lock</a>&amp; lock, const xtime&amp; xt);
        template &lt;typename <a href="lock_concept.html#Lock-concept">Lock</a>, typename <a href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>&gt;
            bool timed_wait(<a href="lock_concept.html#Lock-concept">Lock</a>&amp; lock, const xtime&amp; XT, <a href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a> pred);
    };
 };
 </pre>
 <h4><a name="class-condition-ctors"></a>Class <code>condition</code> constructors 
  and destructor</h4>
 <pre>
 condition();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Constructs a <code>condition</code> object.</dt>
 </dl>
 <pre>
 ~condition();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Destroys <code>*this</code>.</dt>
 </dl>
 <h4><a name="class-condition-modifiers"></a>Class <code>condition</code> modifier 
  functions</h4>
 <pre>
 void notify_one();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> If there is a thread waiting on <code>*this</code>, change 
    that thread&#39;s state to ready. Otherwise there is no effect.</dt>
  <dt><b>Note:</b> If more than one thread is waiting on the condition, it is 
    unspecified which is made ready. After returning to a ready state the notified 
    thread must still acquire the mutex again (which occurs within the call to 
    one of the <code>condition</code> object's wait functions).</dt>
 </dl>
 <pre>
 void notify_all();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Change the state of all threads waiting on <code> *this</code> 
    to ready. If there are no waiting threads, <code> notify_all()</code> has 
    no effect.</dt>
 </dl>
 <pre>
 template &lt;typename ScopedLock&gt;
    void wait(ScopedLock&amp; lock);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>ScopedLock</code> meets the <a href="lock_concept.html#ScopedLock">ScopedLock</a> 
    requirements.</dt>
  <dt><b>Effects:</b> Releases the lock on the <a href="mutex_concept.html">mutex 
    model</a> associated with <code>lock</code>, blocks the current thread of 
    execution until readied by a call to <code>this-&gt;notify_one()</code> or 
    <code> this-&gt;notify_all()</code>, and then reacquires the lock.</dt>
  <dt><b>Throws:</b> <code><a href="exceptions.html#class-lock_error">lock_error</a></code> 
    if <code>!lock.locked()</code></dt>
  <dt><b>Danger:</b> This version should always be used within a loop checking 
    that the state logically associated with the <code>condition</code> has become 
    true. Without the loop, race conditions can ensue due to possible &quot;spurious 
    wake ups&quot;. The second version encapsulates this loop idiom internally 
    and is generally the preferred method.</dt>
 </dl>
 <pre>
 Template&lt;typename ScopedLock, typename Pr&gt;
    void wait(ScopedLock&amp; lock, Pr pred);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>ScopedLock</code> meets the <a href="lock_concept.html#ScopedLock">ScopedLock</a> 
    requirements, return from <code>pred()</code> convertible to bool.</dt>
  <dt><b>Effects:</b> As if: <code>while (!pred()) wait(lock)</code></dt>
  <dt><b>Throws:</b> <code><a href="exceptions.html#class-lock_error">lock_error</a></code> 
    if <code>!lock.locked()</code></dt>
 </dl>
 <pre>
 template &lt;typename ScopedLock&gt;
    bool timed_wait(ScopedLock&amp; lock, const <a href="xtime.html">xtime</a>&amp; XT);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>ScopedLock</code> meets the <a href="lock_concept.html#ScopedLock">ScopedLock</a> 
    requirements.</dt>
  <dt><b>Effects:</b> Releases the lock on the <a href="mutex_concept.html">mutex 
    model</a> associated with the <code> lock</code>, blocks the current thread 
    of execution until readied by a call to <code>this-&gt;notify_one()</code> 
    or <code> this-&gt;notify_all()</code>, or until <code>XT</code>, and then 
    reacquires the lock.</dt>
  <dt><b>Returns:</b> <code>false</code> if <code>XT</code> is reached, otherwise 
    <code>true</code>.</dt>
  <dt><b>Throws:</b> <code><a href="exceptions.html#class-lock_error">lock_error</a></code> 
    if <code>!lock.locked()</code></dt>
  <dt><b>Danger:</b> This version should always be used within a loop checking 
    that the state logically associated with the <code>condition</code> has become 
    true. Without the loop, race conditions can ensue due to &quot;spurious wake 
    ups&quot;. The second version encapsulates this loop idiom internally and 
    is generally the preferred method.</dt>
 </dl>
 <pre>
 Template&lt;typename ScopedLock, typename Pr&gt;
    bool timed_wait(ScopedLock&amp; lock, const <a href="xtime.html">xtime</a>&amp; XT, Pr pred);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>ScopedLock</code> meets the <a href="lock_concept.html#ScopedLock">ScopedLock</a> 
    requirements, return from <code>pred()</code> convertible to bool.</dt>
  <dt><b>Effects:</b> As if:<br>
    <pre>
 while (!pred())
 {
    if (!timed_wait(lock, XT))
        return false;
 }
 return true;
 </pre>
  </dt>
  <dt><b>Returns:</b> <code>false</code> if <code>XT</code> is reached, otherwise 
    <code>true</code>.</dt>
  <dt><b>Throws:</b> <code><a href="exceptions.html#class-lock_error">lock_error</a></code> 
    if <code>!lock.locked()</code></dt>
 </dl>
 <h2><a name="examples"></a>Example(s)</h2>
 <pre>
 #include &lt;iostream&gt;
 #include &lt;vector&gt;
 #include <a href="../../../boost/utility.hpp">&lt;boost/utility.hpp&gt;</a>
 #include <a href="../../../boost/thread/condition.hpp">&lt;boost/thread/condition.hpp&gt;</a>
 #include <a href="../../../boost/thread/thread.hpp">&lt;boost/thread/thread.hpp&gt;</a>
 class bounded_buffer : private boost::noncopyable
 {
 public:
    typedef boost::mutex::scoped_lock lock;
    bounded_buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) { }
    void send (int m) {
        lock lk(monitor);
        while (buffered == circular_buf.size())
            buffer_not_full.wait(lk);
        circular_buf[end] = m;
        end = (end+1) % circular_buf.size();
        ++buffered;
        buffer_not_empty.notify_one();
    }
    int receive() {
        lock lk(monitor);
        while (buffered == 0)
            buffer_not_empty.wait(lk);
        int i = circular_buf[begin];
        begin = (begin+1) % circular_buf.size();
        --buffered;
        buffer_not_full.notify_one();
        return i;
    }
 private:
    int begin, end, buffered;
    std::vector&lt;int&gt; circular_buf;
    boost::condition buffer_not_full, buffer_not_empty;
    boost::mutex monitor;
 };
 bounded_buffer buf(2);
 void sender() {
    int n = 0;
    while (n &lt; 100) {
       buf.send(n);
       std::cout &lt;&lt; &quot;sent: &quot; &lt;&lt; n &lt;&lt; std::endl;
       ++n;
    }
    buf.send(-1);
 }
 void receiver() {
    int n;
    do {
       n = buf.receive();
       std::cout &lt;&lt; &quot;received: &quot; &lt;&lt; n &lt;&lt; std::endl;
    } while (n != -1); // -1 indicates end of buffer
 }
 int main(int, char*[])
 {
    boost::thread thrd1(&amp;sender);
    boost::thread thrd2(&amp;receiver);
    thrd1.join();
    thrd2.join();
    return 0;
 }
 </pre>
 <p>Typical output (dependent on scheduling policies) is:</p>
 <pre>
 sent: 0
 sent: 1
 received: 0
 received: 1
 sent: 2
 sent: 3
 received: 2
 received: 3
 sent: 4
 received: 4
 </pre>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/configuration.html
+++ b/doc/configuration.html
@@ -0,0 +1,94 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Configuration</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Configuration</h2>
    </td>
  </tr>
 </table>
 <hr>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#lib-defined-public">Public Library Defined Macros</a></dt>
  <dt><a href="#lib-defined-impl">Library Defined Implementation Macros</a></dt>
 </dl>
 <h2><a name="introduction"></a>Introduction</h2>
 <p><b>Boost.Threads</b> uses several configuration macros in <a href="../../config/config.htm">&lt;boost/config.hpp&gt;</a>, 
  as well as configuration macros meant to be supplied by the application. These 
  macros are documented here.</p>
 <h2><a name="lib-defined-public"></a>Public Library Defined Macros</h2>
 <p>These macros are defined by <b>Boost.Threads</b> but are expected to be used 
  by application code.</p>
 <table summary="public library defined macros" cellspacing="10" width="100%">
  <tr> 
    <td><b>Macro</b></td>
    <td><b>Meaning</b></td>
  </tr>
  <tr> 
    <td>BOOST_HAS_THREADS</td>
    <td>Indicates that threading support is available. This means both that there 
      is a platform specific implementation for <b>Boost.Threads</b> and that 
      threading support has been enabled in a platform specific manner. For instance, 
      on the Win32 platform there&#39;s an implementation for <b>Boost.Threads</b> 
      but unless the program is compiled against one of the multithreading runtimes 
      (often determined by the compiler predefining the macro _MT) the BOOST_HAS_THREADS 
      macro remains undefined.</td>
  </tr>
 </table>
 <h2><a name="lib-defined-impl"></a>Library Defined Implementation Macros</h2>
 <p>These macros are defined by <b>Boost.Threads</b> and are implementation details 
  of interest only to implementors.</p>
 <table summary="library defined implementation macros" cellspacing="10" width="100%">
  <tr> 
    <td><b>Macro</b></td>
    <td><b>Meaning</b></td>
  </tr>
  <tr> 
    <td>BOOST_HAS_WINTHREADS</td>
    <td>Indicates that the platform has the Microsoft Win32 threading libraries, 
      and that they should be used to implement <b>Boost.Threads</b>.</td>
  </tr>
  <tr> 
    <td>BOOST_HAS_PTHREADS</td>
    <td>Indicates that the platform has the POSIX pthreads libraries, and that 
      they should be used to implement <b>Boost.Threads</b>.</td>
  </tr>
  <tr> 
    <td>BOOST_HAS_FTIME</td>
    <td>Indicates that the implementation should use GetSystemTimeAsFileTime() 
      and the FILETIME type to calculate the current time. This is an implementation 
      detail used by boost::detail::getcurtime().</td>
  </tr>
  <tr> 
    <td>BOOST_HAS_GETTTIMEOFDAY</td>
    <td>Indicates that the implementation should use gettimeofday() to calculate 
      the current time. This is an implementation detail used by boost::detail::getcurtime().</td>
  </tr>
 </table>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/definitions.html
+++ b/doc/definitions.html
@@ -0,0 +1,263 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Definitions</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Definitions</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#definitions">Definitions</a></dt>
  <dl class="page-index"> 
    <dt><a href="#definition-thread">Thread</a></dt>
    <dt><a href="#definition-thread-safe">Thread-safe</a></dt>
    <dt><a href="#definition-thread-state">Thread State</a></dt>
    <dt><a href="#definition-race-condition">Race Condition</a></dt>
    <dt><a href="#definition-deadlock">Deadlock</a></dt>
    <dt><a href="#definition-starvation">Starvation</a></dt>
    <dt><a href="#definition-priority-failure">Priority Failure</a></dt>
    <dt><a href="#definition-visibility">Memory Visibility</a></dt>
  </dl>
  <dt><a href="#acknowledgements">Acknowledgments</a></dt>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>The definitions are given in terms of the <a href=
        "bibliography.html#ISO-98">C++ Standard</a>. References to the standard 
  are in the form [1.2.3/4], which represents the section number, with the paragraph 
  number following the &quot;/&quot;.</p>
 <p>Because the definitions are written in something akin to &quot;standardese&quot;, 
  they can be difficult to understand. The intent isn&#39;t to confuse, but rather 
  to clarify the additional requirements Boost.Threads places on a C++ implementation 
  as defined by the C++ Standard.</p>
 <h2><a name="definitions"></a>Definitions</h2>
 <h3><a name="definition-thread"></a>Thread</h3>
 <p>Thread is short for &quot;thread of execution&quot;. A thread of execution 
  is an execution environment [1.9/7] within the execution environment of a C++ 
  program [1.9]. The main() function [3.6.1] of the program is the initial function 
  of the initial thread. A program in a multithreading environment always has 
  an initial thread even if the program explicitly creates no additional threads.</p>
 <p>Unless otherwise specified, each thread shares all aspects of its execution 
  environment with other threads in the program. Shared aspects of the execution 
  environment include, but are not limited to, the following:</p>
 <ul>
  <li>Static storage duration (static, extern) objects [3.7.1].</li>
 </ul>
 <ul>
  <li>Dynamic storage duration (heap) objects [3.7.3]. Thus each memory allocation 
    will return a unique addresses, regardless of the thread making the allocation 
    request.</li>
 </ul>
 <ul>
  <li>Automatic storage duration (stack) objects [3.7.2] accessed via pointer 
    or reference from another thread.</li>
 </ul>
 <ul>
  <li>Resources provided by the operating system. For example, files.</li>
 </ul>
 <ul>
  <li>The program itself. In other words, each thread is executing some function 
    of the same program, not a totally different program.</li>
 </ul>
 <p>Each thread has its own:</p>
 <ul>
  <li>Registers and current execution sequence (program counter) [1.9/5].</li>
 </ul>
 <ul>
  <li>Automatic storage duration (stack) objects [3.7.2].</li>
 </ul>
 <h3><a name="definition-thread-safe"></a>Thread-safe</h3>
 <p>A program is thread-safe if it has no <a href="#Race condition">race conditions</a>, 
  does not <a href="#Deadlock">deadlock</a>, and has no <a href="#Priority failure">priority 
  failures</a>.</p>
 <p>Note that thread-safety does not necessarily imply efficiency, and than while 
  some thread-safety violations can be determined statically at compile time, 
  many thread-safety errors can only only be detected at runtime.</p>
 <h3><a name="definition-thread-state"></a>Thread State</h3>
 <p>During the lifetime of a thread, it shall be in one of the following states:</p>
 <table summary="thread states" border="1" cellpadding="5">
  <tr> 
    <td><b>State</b></td>
    <td><b>Description</b></td>
  </tr>
  <tr> 
    <td>Ready</td>
    <td>Ready to run, but waiting for a processor.</td>
  </tr>
  <tr> 
    <td>Running</td>
    <td>Currently executing on a processor. Zero or more threads may be running 
      at any time, with a maximum equal to the number of processors.</td>
  </tr>
  <tr> 
    <td>Blocked</td>
    <td>Waiting for some resource other than a processor which is not currently 
      available, or for the completion of calls to library functions [1.9/6]. 
      The term &quot;waiting&quot; is synonymous for &quot;blocked&quot;</td>
  </tr>
  <tr> 
    <td>Terminated</td>
    <td>Finished execution but not yet detached or joined.</td>
  </tr>
 </table>
 <p>Thread state transitions shall occur only as specified:</p>
 <table summary="state transitions" border="1" cellpadding="5">
  <tr> 
    <td><b>From</b></td>
    <td><b>To</b></td>
    <td><b>Cause</b></td>
  </tr>
  <tr> 
    <td> 
      <p align="left">[none]</p>
    </td>
    <td>Ready</td>
    <td>Thread is created by a call to a library function. In the case of the 
      initial thread, creation is implicit and occurs during the startup of the 
      main() function [3.6.1].</td>
  </tr>
  <tr> 
    <td>Ready</td>
    <td>Running</td>
    <td>Processor becomes available.</td>
  </tr>
  <tr> 
    <td>Running</td>
    <td>Ready</td>
    <td>Thread preempted.</td>
  </tr>
  <tr> 
    <td>Running</td>
    <td>Blocked</td>
    <td>Thread calls a library function which waits for a resource or for the 
      completion of I/O.</td>
  </tr>
  <tr> 
    <td>Running</td>
    <td>Terminated</td>
    <td>Thread returns from its initial function, calls a thread termination library 
      function, or is canceled by some other thread calling a thread termination 
      library function.</td>
  </tr>
  <tr> 
    <td>Blocked</td>
    <td>Ready</td>
    <td>The resource being waited for becomes available, or the blocking library 
      function completes.</td>
  </tr>
  <tr> 
    <td>Terminated</td>
    <td>[none]</td>
    <td>Thread is detached or joined by some other thread calling the appropriate 
      library function, or by program termination [3.6.3].</td>
  </tr>
 </table>
 <p>[Note: if a suspend() function is added to the threading library, additional 
  transitions to the blocked state will have to be added to the above table.]</p>
 <h3><a name="definition-race-condition"></a>Race Condition</h3>
 <p>A race condition is what occurs when multiple threads read and write to the 
  same memory without proper synchronization, resulting in an incorrect value 
  being read or written. The result of a race condition may be a bit pattern which 
  isn&#39;t even a valid value for the data type. A race condition results in 
  undefined behavior [1.3.12].</p>
 <p>Race conditions can be prevented by serializing memory access using the tools 
  provided by Boost.Threads.</p>
 <h3><a name="definition-deadlock"></a>Deadlock</h3>
 <p>Deadlock is an execution state where for some set of threads, each thread in 
  the set is blocked waiting for some action by one of the other threads in the 
  set. Since each is waiting on the others, none will ever become ready again.</p>
 <h3><a name="definition-starvation"></a>Starvation</h3>
 <p>The condition in which a thread is not making sufficient progress in its work 
  during a given time interval.</p>
 <h3><a name="definition-priority-failure"></a>Priority Failure</h3>
 <p>A priority failure (such as priority inversion or infinite overtaking) occurs 
  when threads executed in such a sequence that required work is not performed 
  in time to be useful.</p>
 <h3><a name="definition-visibility"></a>Memory Visibility</h3>
 <p>An address [1.7] shall always point to the same memory byte, regardless of 
  the thread or processor dereferencing the address.</p>
 <p>An object [1.8, 1.9] is accessible from multiple threads if it is of static 
  storage duration (static, extern) [3.7.1], or if a pointer or reference to it 
  is explicitly or implicitly dereferenced in multiple threads.</p>
 <p>For an object accessible from multiple threads, the value of the object accessed 
  from one thread may be indeterminate or different than the value accessed from 
  another thread, except under the conditions specified in the following table. 
  For the same row of the table, the value of an object accessible at the indicated 
  sequence point in thread A will be determinate and the same if accessed at or 
  after the indicated sequence point in thread B, provided the object is not otherwise 
  modified. In the table, the &quot;sequence point at a call&quot; is the sequence 
  point after the evaluation of all function arguments [1.9/17], while the &quot;sequence 
  point after a call&quot; is the sequence point after the copying of the returned 
  value...&quot; [1.9/17].</p>
 <table summary="memory visibility" border="1" cellpadding="5">
  <tr> 
    <td align="center"><b>Thread A</b></td>
    <td align="center"><b>Thread B</b></td>
  </tr>
  <tr> 
    <td>The sequence point at a call to a library thread-creation function.</td>
    <td>The first sequence point of the initial function in the new thread created 
      by the Thread A call.</td>
  </tr>
  <tr> 
    <td>The sequence point at a call to a library function which locks a mutex, 
      directly or by waiting for a condition variable.</td>
    <td>The sequence point after a call to a library function which unlocks the 
      same mutex.</td>
  </tr>
  <tr> 
    <td>The last sequence point before thread termination.</td>
    <td>The sequence point after a call to a library function which joins the 
      terminated thread.</td>
  </tr>
  <tr> 
    <td>The sequence point at a call to a library function which signals or broadcasts 
      a condition variable.</td>
    <td>The sequence point after the call to the library function which was waiting 
      on that same condition variable or signal.</td>
  </tr>
 </table>
 <p>The architecture of the execution environment and the observable behavior of 
  the abstract machine [1.9] shall be the same on all processors.</p>
 <p>The latitude granted by the C++ standard for an implementation to alter the 
  definition of observable behavior of the abstract machine to include additional 
  library I/O functions [1.9/6] is extended to include threading library functions.</p>
 <p>When an exception is thrown and there is no matching exception handler in the 
  same thread, behavior is undefined. The preferred behavior is the same as when 
  there is no matching exception handler in a program [15.3/9]. That is, terminate() 
  is called, and it is implementation defined whether or not the stack is unwound.</p>
 <h2><a name="acknowledgements"></a>Acknowledgments</h2>
 <p>This document has been much improved by the incorporation of comments from 
  William Kempf.</p>
 <p>The visibility rules are based on <a href=
        "bibliography.html#Butenhof-97">[Butenhof 97]</a>.</p>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/exceptions.html
+++ b/doc/exceptions.html
@@ -0,0 +1,110 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Header &lt;boost/thread/exceptions.hpp&gt;</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Header &lt;<a href="../../../boost/thread/exceptions.hpp">boost/thread/exceptions.hpp</a>&gt;</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#classes">Classes</a></dt>
  <dl class="page-index"> 
    <dt><a href="#class-lock_error">Class <code>lock_error</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-lock_error-synopsis">Class <code>lock_error</code> synopsis</a></dt>
      <dt><a href="#class-lock_error-ctors">Class <code>lock_error</code> constructors 
        and destructor</a></dt>
    </dl>
    <dt><a href="#class-thread_resource_error">Class <code>thread_resource_error</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-thread_resource_error-synopsis">Class <code>thread_resource_error</code> 
        synopsis</a></dt>
      <dt><a href="#class-thread_resource_error-ctors">Class <code>thread_resource_error</code> 
        constructors and destructor</a></dt>
    </dl>
  </dl>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>Include the header &lt;<a href="../../../boost/thread/exceptions.hpp">boost/thread/exceptions.hpp</a>&gt; 
  to define the exception types that may be thrown by <b>Boost.Threads</b> classes.</p>
 <h2><a name="classes"></a>Classes</h2>
 <h3><a name="class-lock_error"></a>Class <code>lock_error</code></h3>
 <p>The lock_error class defines an exception type thrown to indicate a locking 
  related error has been detected. Examples of such errors include a lock operation 
  which can be determined to result in a deadlock, or unlock operations attempted 
  by a thread that does not own the lock. </p>
 <h4><a name="class-lock_error-synopsis"></a>Class <code>lock_error</code> synopsis</h4>
 <pre>
 namespace boost
 {
    class lock_error : public std::logical_error
 	{
 	public:
 	    lock_error();
 	};
 };
 </pre>
 <h4><a name="class-lock_error-ctors"></a>Class <code>lock_error</code> constructors 
  and destructor</h4>
 <pre>
 lock_error();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Constructs a <code>lock_error</code> object.</dt>
 </dl>
 <h3><a name="class-thread_resource_error"></a>Class <code>thread_resource_error</code></h3>
 <p>The thread_resource_error class defines an exception type that is thrown by 
  constructors in the Boost.Threads library when thread related resources can 
  not be acquired. This does not include memory allocation failures which instead 
  throw std::bad_alloc. </p>
 <h4><a name="class-thread_resource_error-synopsis"></a>Class <code>thread_resource_error</code> 
  synopsis</h4>
 <pre>
 namespace boost
 {
    class thread_resource_error : public std::runtime_error
 	{
 	public:
 	    thread_resource_error();
 	};
 };
 </pre>
 <h4><a name="class-thread_resource_error-ctors"></a>Class <code>thread_resource_error</code> 
  constructors and destructor</h4>
 <pre>
 thread_resource_error();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Constructs a <code>thread_resource_error</code> object.</dt>
 </dl>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/faq.html
+++ b/doc/faq.html
@@ -0,0 +1,183 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - FAQ</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Frequently Asked Questions (FAQs)</h2>
    </td>
  </tr>
 </table>
 <hr>
 <dl class="page-index"> 
  <dt><a href="#question1">1. Are lock objects thread safe?</a></dt>
  <dt><a href="#question2a">2a. Why was <b>Boost.Threads</b> modeled after (specific 
    library name)?</a></dt>
  <dt><a href="#question2b">2b. Why wasn't <b>Boost.Threads</b> modeled after 
    (specific library name)?</a></dt>
  <dt><a href="#question3">3. Why do mutexes have noncopyable semantics?</a></dt>
  <dt><a href="#question4">4. How can you prevent deadlock from occurring when 
    a thread must lock multiple mutexes?</a></dt>
  <dt><a href="#question5">5. Don't noncopyable mutex semantics mean that a class 
    with a mutex member will be noncopyable as well?</a></dt>
  <dt><a href="#question6">6. How can you lock a mutex member in a const member 
    function (in order to implement the monitor pattern)?</a></dt>
  <dt><a href="#question7">7. Why supply condition variables rather than event 
    variables?</a></dt>
  <dt><a href="#question8">8. Why isn't thread cancellation or termination provided?</a></dt>
  <dt><a href="#question9">9. Is it safe for threads to share automatic storage 
    duration (stack) objects via pointers or references?</a></dt>
  <dt><a href="#question10">10. Why has class semaphore disappeared?</a></dt>
 </dl>
 <h2><a name="question1"></a>1. Are lock objects <a href="definitions.html#definition-thread-safe"> 
  thread safe</a>?</h2>
 <p><b>No!</b> Lock objects are not meant to be shared between threads. They are 
  meant to be short-lived objects created on automatic storage within a code block. 
  Any other usage is just likely to lead to errors and won&#39;t really be of 
  actual benefit any way. Share <a href=
        "mutex_concept.html">mutexes</a>, not locks. For more information see 
  the <a href="rationale.html#lock_objects">rationale</a> behind the design for 
  lock objects.</p>
 <h2><a name="question2a"></a>2a. Why was <b>Boost.Threads</b> modeled after (specific 
  library name)?</h2>
 <p>It wasn&#39;t. Boost.Threads was designed from scratch. Extensive design discussions 
  involved numerous people representing a wide range of experience across many 
  platforms. To ensure portability, the initial implements were done in parallel 
  using POSIX Threads and the Win32 threading API. But the Boost.Threads design 
  is very much in the spirit of C++, and thus doesn&#39;t model such C based APIs.</p>
 <h2><a name="question2b"></a>2b. Why wasn&#39;t Boost.Threads modeled after (specific 
  library name)?</h2>
 <p>Existing C++ libraries either seemed dangerous (often failing to take advantage 
  of prior art to reduce errors) or had excessive dependencies on library components 
  unrelated to threading. Existing C libraries couldn&#39;t meet our C++ requirements, 
  and were also missing certain features. For instance, the WIN32 thread API lacks 
  condition variables, even though these are critical for the important Monitor 
  pattern <a href="bibliography.html#Schmidt-00">[Schmidt 00]</a>.</p>
 <h2><a name="question3"></a>3. Why do <a href="mutex_concept.html">Mutexes</a> 
  have noncopyable semantics?</h2>
 <p>To ensure that <a href="definitions.html#Deadlock">deadlocks</a> don&#39;t 
  occur. The only logical form of copy would be to use some sort of shallow copy 
  semantics in which multiple mutex objects could refer to the same mutex state. 
  This means that if ObjA has a mutex object as part of its state and ObjB is 
  copy constructed from it, then when ObjB::foo() locks the mutex it has effectively 
  locked ObjA as well. This behavior can result in deadlock. Other copy semantics 
  result in similar problems (if you think you can prove this to be wrong then 
  supply us with an alternative and we&#39;ll reconsider).</p>
 <h2><a name="question4"></a>4. How can you prevent <a href="definitions.html#Deadlock"> 
  deadlock</a> from occurring when a thread must lock multiple mutexes?</h2>
 <p>Always lock them in the same order. One easy way of doing this is to use each 
  mutex&#39;s address to determine the order in which they are locked. A future 
  Boost.Threads concept may wrap this pattern up in a reusable class.</p>
 <h2><a name="question5"></a>5. Don&#39;t noncopyable <a href="mutex_concept.html">mutex</a> 
  semantics mean that a class with a mutex member will be noncopyable as well?</h2>
 <p>No, but what it does mean is that the compiler can&#39;t generate a copy constructor 
  and assignment operator, so they will have to be coded explicitly. This is a 
  <b>good thing</b>, however, since the compiler generated operations would not 
  be <a href=
        "definitions.html#Thread-safe">thread-safe</a>. The following is a simple 
  example of a class with copyable semantics and internal synchronization through 
  a mutex member.</p>
 <pre>
 class counter
 {
 public:
   // Doesn't need synchronization since there can be no references to *this
   // until after it's constructed!
   explicit counter(int initial_value)
      : m_value(initial_value)
   {
   }
   // We only need to synchronize other for the same reason we don't have to
   // synchronize on construction!
   counter(const counter&amp; other)
   {
      boost::mutex::scoped_lock scoped_lock(other.m_mutex);
      m_value = other.m_value;
   }
   // For assignment we need to synchronize both objects!
   const counter&amp; operator=(const counter&amp; other)
   {
      if (this == &amp;other)
         return *this;
      boost::mutex::scoped_lock lock1(&amp;m_mutex &lt; &amp;other.m_mutex ? m_mutex : other.m_mutex);
      boost::mutex::scoped_lock lock2(&amp;m_mutex &gt; &amp;other.m_mutex ? m_mutex : other.m_mutex);
      m_value = other.m_value;
      return *this;
   }
   int value() const
   {
      boost::mutex::scoped_lock scoped_lock(m_mutex);
      return m_value;
   }
   int increment()
   {
      boost::mutex::scoped_lock scoped_lock(m_mutex);
      return ++m_value;
   }
 private:
   mutable boost::mutex m_mutex;
   int m_value;
 };
 </pre>
 <h2><a name="question6"></a>6. How can you lock a <a href="mutex_concept.html">mutex</a> 
  member in a const member function, in order to implement the Monitor Pattern?</h2>
 <p>The Monitor Pattern mutex <a href="bibliography.html#Schmidt-00"> [Schmidt 
  00]</a> should simply be declared as mutable. See the example code above. The 
  internal state of mutex types could have been made mutable, with all lock calls 
  made via const functions, but this does a poor job of documenting the actual 
  semantics (and in fact would be incorrect since the logical state of a locked 
  mutex clearly differs from the logical state of an unlocked mutex). Declaring 
  a mutex member as mutable clearly documents the intended semantics.</p>
 <h2><a name="question7"></a>7. Why supply <a href="condition.html">condition variables</a> 
  rather than <a href="rationale.html#Events">event variables</a>?</h2>
 <p>Condition variables result in user code much less prone to <a href=
        "definitions.html#Race condition">race conditions</a> than event variables. 
  See <a href="rationale.html#Events">Rationale</a> for analysis. Also see <a href="bibliography.html#Hoare-74">[Hoare 
  74]</a> and <a href="bibliography.html#Schmidt-00">[Schmidt 00]</a>.</p>
 <h2><a name="question8"></a>8. Why isn&#39;t thread cancellation or termination 
  provided?</h2>
 <p>There&#39;s a valid need for thread termination, so at some point Boost.Threads 
  probably will include it, but only after we can find a truly safe (and portable) 
  mechanism for this concept.</p>
 <h2><a name="question9"></a>9. Is it safe for threads to share automatic storage 
  duration (stack) objects via pointers or references?</h2>
 <p>Only if you can guarantee that the lifetime of the stack object will not end 
  while other threads might still access the object. Thus the safest practice 
  is to avoid sharing stack objects, particularly in designs where threads are 
  created and destroyed dynamically. Restrict sharing of stack objects to simple 
  designs with very clear and unchanging function and thread lifetimes. (Suggested 
  by Darryl Green).</p>
 <h2><a name="question10"></a>10. Why has class semaphore disappeared?</h2>
 <p>Semaphore was removed as too error prone. The same effect can be achieved with 
  greater safety by the combination of a mutex and a condition variable.</p>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/index.html
+++ b/doc/index.html
@@ -0,0 +1,155 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Index</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="index"> 
  <dt><a href="overview.html">Overview</a></dt>
  <dt><a href="mutex_concept.html">Mutex Concepts</a></dt>
  <dl class="index"> 
    <dt><a href="mutex_concept.html#Mutex">Mutex</a></dt>
    <dt><a href="mutex_concept.html#TryMutex">TryMutex</a></dt>
    <dt><a href="mutex_concept.html#TimedMutex">TimedMutex</a></dt>
  </dl>
  <dt><a href="lock_concept.html">Lock Concepts</a></dt>
  <dl class="index"> 
    <dt><a href="lock_concept.html#Lock">Lock</a></dt>
    <dt><a href="lock_concept.html#ScopedLock">ScopedLock</a></dt>
    <dt><a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a></dt>
    <dt><a href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a></dt>
  </dl>
  <dt>Reference</dt>
  <dl class="index"> 
    <dt><a href="condition.html"><code>&lt;boost/thread/condition.hpp&gt;</code></a></dt>
    <dl class="index"> 
      <dt><a href="condition.html#classes">Classes</a></dt>
      <dl class="index"> 
        <dt><a href="condition.html#class-condition"><code>condition</code></a></dt>
      </dl>
    </dl>
  </dl>
  <dl class="index"> 
    <dt><a href="exceptions.html"><code>&lt;boost/thread/exceptions.hpp&gt;</code></a></dt>
    <dl class="index"> 
      <dt><a href="exceptions.html#classes">Classes</a></dt>
      <dl class="index"> 
        <dt><a href="exceptions.html#class-lock_error"><code>lock_error</code></a></dt>
        <dt><a href="exceptions.html#class-thread_resource_error"><code>thread_resource_error</code></a></dt>
      </dl>
    </dl>
  </dl>
  <dl class="index"> 
    <dt><a href="mutex.html"><code>&lt;boost/thread/mutex.hpp&gt;</code></a></dt>
    <dl class="index"> 
      <dt><a href="mutex.html#classes">Classes</a></dt>
      <dl class="index"> 
        <dt><a href="mutex.html#class-mutex"><code>mutex</code></a></dt>
        <dt><a href="mutex.html#class-try_mutex"><code>try_mutex</code></a></dt>
        <dt><a href="mutex.html#class-timed_mutex"><code>timed_mutex</code></a></dt>
      </dl>
    </dl>
  </dl>
  <dl class="index"> 
    <dt><a href="once.html"><code>&lt;boost/thread/once.hpp&gt;</code></a></dt>
    <dl class="index"> 
      <dt><a href="once.html#macros">Macros</a></dt>
      <dl class="index"> 
        <dt><a href="once.html#macro-BOOST_ONCE_INIT"><code>BOOST_ONCE_INIT</code></a></dt>
      </dl>
      <dt><a href="once.html#types">Types</a></dt>
      <dl class="index"> 
        <dt><a href="once.html#type-once_flag"><code>once_flag</code></a></dt>
      </dl>
      <dt><a href="once.html#functions">Functions</a></dt>
      <dl class="index"> 
        <dt><a href="once.html#function-call_once"><code>call_once</code></a></dt>
      </dl>
    </dl>
  </dl>
  <dl class="index"> 
    <dt><a href="recursive_mutex.html"><code>&lt;boost/thread/recursive_mutex.hpp&gt;</code></a></dt>
    <dl class="index"> 
      <dt><a href="recursive_mutex.html#classes">Classes</a></dt>
      <dl class="index"> 
        <dt><a href="recursive_mutex.html#class-recursive_mutex"><code>recursive_mutex</code></a></dt>
        <dt><a href="recursive_mutex.html#class-recursive_try_mutex"><code>recursive_try_mutex</code></a></dt>
        <dt><a href="recursive_mutex.html#class-recursive_timed_mutex"><code>recursive_timed_mutex</code></a></dt>
      </dl>
    </dl>
  </dl>
  <dl class="index"> 
    <dt><a href="thread.html"><code>&lt;boost/thread/thread.hpp&gt;</code></a></dt>
    <dl class="index"> 
      <dt><a href="thread.html#classes">Classes</a></dt>
      <dl class="index"> 
        <dt><a href="thread.html#class-thread"><code>thread</code></a></dt>
        <dt><a href="thread.html#class-thread_group"><code>thread_group</code></a></dt>
      </dl>
    </dl>
  </dl>
  <dl class="index"> 
    <dt><a href="tss.html"><code>&lt;boost/thread/tss.hpp&gt;</code></a></dt>
    <dl class="index"> 
      <dt><a href="tss.html#classes">Classes</a></dt>
      <dl class="index"> 
        <dt><a href="tss.html#class-thread_specific_ptr"><code>thread_specific_ptr</code></a></dt>
      </dl>
    </dl>
  </dl>
  <dl class="index"> 
    <dt><a href="xtime.html"><code>&lt;boost/thread/xtime.hpp&gt;</code></a></dt>
    <dl class="index"> 
      <dt><a href="xtime.html#values">Values</a></dt>
      <dl class="page-index"> 
        <dt><a href="xtime.html#value-spec"><code>TIME_UTC</code></a></dt>
      </dl>
      <dt><a href="xtime.html#classes">Classes</a></dt>
      <dl class="page-index"> 
        <dt><a href="xtime.html#class-xtime"><code>xtime</code></a></dt>
      </dl>
      <dt><a href="xtime.html#functions">Functions</a></dt>
      <dl class="page-index"> 
        <dt><a href="xtime.html#function-xtime_get"><code>xtime_get</code></a></dt>
      </dl>
    </dl>
  </dl>
  <dt><a href="configuration.html">Configuration Information</a></dt>
  <dt><a href="introduction.html">Introduction to Design</a></dt>
  <dt><a href="rationale.html">Rationale</a></dt>
  <dt><a href="definitions.html">Definitions</a></dt>
  <dt><a href="faq.html">Frequently Asked Questions (FAQs)</a></dt>
  <dt><a href="bibliography.html">Bibliography</a></dt>
  <dt><a href="acknowledgments.html">Acknowledgments</a></dt>
 </dl>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/introduction.html
+++ b/doc/introduction.html
@@ -0,0 +1,159 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Introduction to Design</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Introduction to Design</h2>
    </td>
  </tr>
 </table>
 <hr>
 <dl class="page-index"> 
  <dt><a href="#motivation">Motivation</a></dt>
  <dt><a href="#goals">Goals</a></dt>
  <dt><a href="#phases">Iterative Phases</a></dt>
  <dl class="page-index"> 
    <dt><a href="#phase1">Phase 1, Synchronization Primitives</a></dt>
    <dt><a href="#phase2">Phase 2, Thread Management and Thread Specific Storage</a></dt>
    <dt><a href="#next-phase">The Next Phase</a></dt>
  </dl>
 </dl>
 <h2><a name="motivation"></a>Motivation</h2>
 <p>With client/server and three-tier architectures becoming common place in today&#39;s 
  world, it&#39;s becoming increasingly important for programs to be able to handle 
  parallel processing. Modern day operating systems usually provide some support 
  for this through native thread APIs. Unfortunately, writing portable code that 
  makes use of parallel processing in C++ is made very difficult by a lack of 
  a standard interface for these native APIs. Further, these APIs are almost universally 
  C APIs and fail to take advantage of C++&#39;s strengths, or to address C++&#39;s 
  issues.</p>
 <p>The <b>Boost.Threads</b> library is an attempt to define a portable interface 
  for writing parallel processes in C++.</p>
 <h2><a name="goals"></a>Goals</h2>
 <p>The <b>Boost.Threads</b> library has several goals that should help to set 
  it apart from other solutions. These goals are listed in order of precedence 
  with full descriptions below.</p>
 <ul>
  <li> <b>Portability</b> 
    <p><b>Boost.Threads</b> was designed to be highly portable. The goal is for 
      the interface to be easily implemented on any platform that supports threads, 
      and possibly even on platforms without native thread support.</p>
  </li>
  <li> <b>Safety</b> 
    <p><b>Boost.Threads</b> was designed to be as safe as possible. Writing <a href="definitions.html#Thread-safe">thread-safe</a> 
      code is very difficult and successful libraries must strive to insulate 
      the programmer from dangerous constructs as much as possible. This is accomplished 
      in several ways:</p>
    <ul>
      <li> 
        <p align="left">C++ language features are used make correct usage easy 
          (if possible, the default) and error-prone impossible or at least more 
          difficult. For example, see the <a href="mutex_concept.html">Mutex</a> 
          and <a href="lock_concept.html">Lock</a> designs, and how note how they 
          interact.</p>
      </li>
      <li> 
        <p align="left">Certain traditional concurrent programming features are 
          considered so error-prone that they are not provided at all. For example, 
          see the <a
                        href="rationale.html#Events">Events Not Provided</a> rationale.</p>
      </li>
      <li> 
        <p align="left">Dangerous features, or features which may be misused, 
          are identified as such in the documentation to make users aware of potential 
          pitfalls.</p>
      </li>
    </ul>
  </li>
  <li> <b>Flexibility</b> 
    <p><b>Boost.Threads</b> was designed to be flexible. This goal is often at 
      odds with <i>safety</i>. When functionality might be compromised by the 
      desire to keep the interface safe, <b> Boost.Threads</b> has been designed 
      to provide the functionality, but to make it&#39;s use prohibitive for general 
      use. In other words, the interfaces have been designed such that it's usually 
      obvious when something is unsafe, and the documentation is written to explain 
      why.</p>
  </li>
  <li> <b>Efficiency</b> 
    <p><b>Boost.Threads</b> was designed to be as efficient as possible. When 
      building a library on top of another library there is always a danger that 
      the result will be so much slower than the &quot;native&quot; API that programmers 
      are inclined to ignore the higher level API. <b>Boost.Threads</b> was designed 
      to minimize the chances of this occurring. The interfaces have been crafted 
      to allow an implementation the greatest chance of being as efficient as 
      possible. This goal is often at odds with the goal for <i>safety</i>. Every 
      effort was made to ensure efficient implementations, but when in conflict 
      <i>safety</i> has always taken precedence.</p>
  </li>
 </ul>
 <h2><a name="phases"></a>Iterative Phases</h2>
 <p>Another goal of <b>Boost.Threads</b> was to take a dynamic, iterative approach 
  in its development. The computing industry is still exploring the concepts of 
  parallel programming. Most thread libraries supply only simple primitive concepts 
  for thread synchronization. These concepts are very simple, but they are very 
  difficult to use safely or to provide formal proofs for constructs built on 
  top of them. There has been a lot of research in other concepts, such as in 
  &quot;Communicating Sequential Processes.&quot; <b>Boost.Threads</b> was designed 
  in iterative steps, providing the building blocks necessary for the next step, 
  and giving the researcher the tools necessary to explore new concepts in a portable 
  manner.</p>
 <p>Given the goal of following a dynamic, iterative approach <b> Boost.Threads</b> 
  shall go through several growth cycles. Each phase in its development shall 
  be roughly documented here.</p>
 <h3><a name="phase1"></a>Phase 1, Synchronization Primitives</h3>
 <p>Boost is all about providing high quality libraries with implementations for 
  many platforms. Unfortunately, there&#39;s a big problem faced by developers 
  wishing to supply such high quality libraries, namely thread-safety. The C++ 
  standard doesn&#39;t address threads at all, but real world programs often make 
  use of native threading support. A portable library that doesn&#39;t address 
  the issue of thread-safety is there for not much help to a programmer who wants 
  to use the library in his multithreaded application. So there&#39;s a very great 
  need for portable primitives that will allow the library developer to create 
  <a href="definitions.html#Thread-safe"> thread-safe</a> implementations. This 
  need far out weighs the need for portable methods to create and manage threads.</p>
 <p>Because of this need, the first phase of <b>Boost.Threads</b> focuses solely 
  on providing portable primitive concepts for thread synchronization. Types provided 
  in this phase include the <a href="mutex.html"> mutex/try_mutex/timed_mutex</a>, 
  <a href="recursive_mutex.html"> recursive_mutex/recursive_try_mutex/recursive_timed_mutex</a> 
  and <a href="exceptions.html#class-lock_error">lock_error</a>. These are considered 
  the &quot;core&quot; synchronization primitives, though there are others that 
  will be added in later phases.</p>
 <h3><a name="phase2"></a>Phase 2, Thread Management and Thread Specific Storage</h3>
 <p>This phase addresses the creation and management of threads and provides a 
  mechanism for thread specific storage (data associated with a thread instance). 
  Thread management is a tricky issue in C++, so this phase addresses only the 
  basic needs of multithreaded program. Later phases are likely to add additional 
  functionality in this area. This phase of <b>Boost.Threads</b> adds the <a href="thread.html">thread</a> 
  and <a href="tss.html#class-thread_specific_ptr">thread_specific_ptr</a> types. 
  With these additions the <b>Boost.Threads</b> library can be considered minimal 
  but complete.</p>
 <h3><a name="next-phase"></a>The Next Phase</h3>
 <p>The next phase will address more advanced synchronization concepts, such as 
  read/write mutexes and barriers.</p>
 <hr>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/lock_concept.html
+++ b/doc/lock_concept.html
@@ -0,0 +1,194 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - ScopedLock Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">ScopedLock Concept</h2>
    </td>
  </tr>
 </table>
 <hr>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#concept-requirements">Concept Requirements</a></dt>
  <dl class="page-index"> 
    <dt><a href="#Lock-concept">Lock Concept</a></dt>
    <dt><a href="#ScopedLock-concept">ScopedLock Concept</a></dt>
    <dt><a href="#ScopedTryLock-concept">ScopedTryLock Concept</a></dt>
    <dt><a href="#ScopedTimedLock-concept">ScopedTimedLock Concept</a></dt>
  </dl>
 </dl>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>A lock object provides a safe means for locking and unlocking a mutex object 
  (an object whose type is a model of <a href="mutex_concept.html">Mutex</a> or 
  one of its refinements). In other words they are an implementation of the <i>Scoped 
  Locking</i> <a href="bibliography.html#Schmidt-00">[Schmidt 00]</a> pattern. 
  The <a href="#ScopedLock-concept">ScopedLock</a> concept, with <a href="#ScopedTryLock-concept">ScopedTryLock</a> 
  and <a href="#ScopedTimedLock-concept">ScopedTimedLock</a> refinements, formalize 
  the requirements.</p>
 <p>Lock objects are constructed with a reference to a mutex object and typically 
  acquire ownership of the mutex object by setting its state to locked. They also 
  ensure ownership is relinquished in the destructor. Lock objects also expose 
  functions to query the lock status and to manually lock and unlock the mutex 
  object.</p>
 <p>Lock objects are meant to be short lived, expected to be used at block scope 
  only. The lock objects are not <a href="definitions.html#definition-thread-safe">thread-safe</a>. 
  Lock objects must maintain state to indicate whether or not they&#39;ve been 
  locked and this state is not protected by any synchronization concepts. For 
  this reason a lock object should never be shared between multiple threads.</p>
 <h2><a name="concept-requirements"></a>Concept Requirements</h2>
 <h3><a name="Lock-concept"></a>Lock Concept</h3>
 <p>For a Lock type <code>L</code> and an object <code>lk</code> and const object 
  <code>clk</code> of that type, the following expressions must be well-formed 
  and have the indicated effects.</p>
 <table summary="Lock expressions" border="1" cellpadding="5">
  <tr> 
    <td><b>Expression</b></td>
    <td><b>Effects</b></td>
  </tr>
  <tr> 
    <td valign="top"><code>(&amp;lk)-&gt;~L();</code></td>
    <td><code>if (locked()) unlock();</code></td>
  </tr>
  <tr> 
    <td valign="top"><code>(&amp;clk)-&gt;operator const void*()</code></td>
    <td>Returns type void*, non-zero if if the associated mutex object has been 
      locked by <code>clk</code>, otherwise 0.</td>
  </tr>
  <tr> 
    <td valign="top"><code>clk.locked()</code></td>
    <td>Returns a <code>bool</code>, <code>(&amp;clk)-&gt;operator const void*() 
      != 0</code></td>
  </tr>
  <tr> 
    <td valign="top"><code>lk.lock()</code></td>
    <td>Throws <code>lock_error</code> if <code>locked()</code>. If the associated 
      mutex object is already locked by some other thread, places the current 
      thread in the <a href="definitions.html#State">Blocked</a> state until the 
      associated mutex is unlocked, after which the current thread is placed in 
      the <a href="definitions.html#State"> Ready</a> state, eventually to be 
      returned to the <a href="definitions.html#State">Running</a> state. If the 
      associated mutex object is already locked by the same thread the behavior 
      is dependent on the <a href="mutex_concept.html#locking-strategies">locking 
      strategy</a> of the associated mutex object.<br>
      Postcondition: <code>locked() == true</code></td>
  </tr>
  <tr> 
    <td valign="top"><code>lk.unlock()</code></td>
    <td>If <code>!locked()</code>, throws <code>lock_error</code>, otherwise unlocks 
      the associated mutex.<br>
      Postcondition: <code>!locked()</code></td>
  </tr>
 </table>
 <h3><a name="ScopedLock-concept"></a>ScopedLock Concept</h3>
 <p>A ScopedLock is a refinement of <a href="#Lock">Lock</a>. For a ScopedLock 
  type <code>L</code> and an object <code>lk</code> of that type, and an object 
  <code>m</code> of a type meeting the <a href="mutex_concept.html#Mutex-concept">Mutex</a> 
  requirements, and an object <code>b</code> of type <code>bool</code>, the following 
  expressions must be well-formed and have the indicated effects.</p>
 <table summary="ScopedLock expressions" border="1" cellpadding="5">
  <tr> 
    <td><b>Expression</b></td>
    <td><b>Effects</b></td>
  </tr>
  <tr> 
    <td valign="top"><code>L lk(m);</code></td>
    <td>Constructs an object <code>lk</code>, and associates mutex object <code>m</code> 
      with it, then calls <code>lock()</code></td>
  </tr>
  <tr> 
    <td valign="top"><code>L lk(m,b);</code></td>
    <td>Constructs an object <code>lk</code>, and associates mutex object <code>m</code> 
      with it, then if <code>b</code>, calls <code>lock()</code></td>
  </tr>
 </table>
 <h3><a name="ScopedTryLock-concept"></a>ScopedTryLock Concept</h3>
 <p>A ScopedTryLock is a refinement of <a href="#Lock-concept">Lock</a>. For a 
  ScopedTryLock type <code>L</code> and an object <code>lk</code> of that type, 
  and an object <code>m</code> of a type meeting the <a href="mutex_concept.html#TryMutex-concept">TryMutex</a> 
  requirements, and an object <code>b</code> of type <code>bool</code>, the following 
  expressions must be well-formed and have the indicated effects.</p>
 <table summary="ScopedTryLock expressions" border="1" cellpadding="5">
  <tr> 
    <td><b>Expression</b></td>
    <td><b>Effects</b></td>
  </tr>
  <tr> 
    <td valign="top"><code>L lk(m);</code></td>
    <td>Constructs an object <code>lk</code>, and associates mutex object <code>m</code> 
      with it, then calls <code>try_lock()</code></td>
  </tr>
  <tr> 
    <td valign="top"><code>L lk(m,b);</code></td>
    <td>Constructs an object <code>lk</code>, and associates mutex object <code>m</code> 
      with it, then if <code>b</code>, calls <code> lock()</code></td>
  </tr>
  <tr> 
    <td valign="top"><code>lk.try_lock()</code></td>
    <td>If locked(), throws <code>lock_error</code>. Makes a non-blocking attempt 
      to lock the associated mutex object, returning <code>true</code> if the 
      lock attempt is successful, otherwise <code>false</code>. If the associated 
      mutex object is already locked by the same thread the behavior is dependent 
      on the <a href="mutex_concept.html#locking-strategies">locking strategy</a> 
      of the associated mutex object.</td>
  </tr>
 </table>
 <h3><a name="ScopedTimedLock-concept"></a>ScopedTimedLock Concept</h3>
 <p>A ScopedTimedLock is a refinement of <a href="#Lock">Lock</a>. For a ScopedTimedLock 
  type <code>L</code> and an object <code>lk</code> of that type, and an object 
  <code>m</code> of a type meeting the <a href="mutex_concept.html#TimedMutex">TimedMutex</a> 
  requirements, and an object <code>b</code> of type <code>bool</code>, and an 
  object <code>t</code> of type <code><a href="xtime.html"> xtime</a></code>, 
  the following expressions must be well-formed and have the indicated effects.</p>
 <table summary="ScopedTimedLock expressions" border="1" cellpadding=
        "5">
  <tr> 
    <td><b>Expression</b></td>
    <td><b>Effects</b></td>
  </tr>
  <tr> 
    <td valign="top"><code>L lk(m,t);</code></td>
    <td>Constructs an object <code>lk</code>, and associates mutex object <code>m</code> 
      with it, then calls <code> timed_lock(t)</code></td>
  </tr>
  <tr> 
    <td valign="top"><code>L lk(m,b);</code></td>
    <td>Constructs an object <code>lk</code>, and associates mutex object <code>m</code> 
      with it, then if <code>b</code>, calls <code> lock()</code></td>
  </tr>
  <tr> 
    <td valign="top"><code>lk.timed_lock(t)</code></td>
    <td>If locked(), throws lock_error. Makes a blocking attempt to lock the associated 
      mutex object, and returns <code>true</code> if successful within the specified 
      time <code>t</code>, otherwise <code>false</code>. If the associated mutex 
      object is already locked by the same thread the behavior is dependent on 
      the <a href="mutex_concept.html#locking-strategies">locking strategy</a> 
      of the associated mutex object.</td>
  </tr>
 </table>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/mutex.html
+++ b/doc/mutex.html
@@ -0,0 +1,288 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Header &lt;boost/thread/mutex.hpp&gt;</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Header &lt;<a href="../../../boost/thread/mutex.hpp">boost/thread/mutex.hpp</a>&gt;</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#classes">Classes</a></dt>
  <dl class="page-index"> 
    <dt><a href="#class-mutex">Class <code>mutex</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-mutex-synopsis">Class <code>mutex</code> synopsis</a></dt>
      <dt><a href="#class-mutex-ctors">Class <code>mutex</code> constructors and 
        destructor</a></dt>
    </dl>
  </dl>
  <dl class="page-index"> 
    <dt><a href="#class-try_mutex">Class <code>try_mutex</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-try_mutex-synopsis">Class <code>try_mutex</code> synopsis</a></dt>
      <dt><a href="#class-try_mutex-ctors">Class <code>try_mutex</code> constructors 
        and destructor</a></dt>
    </dl>
  </dl>
  <dl class="page-index"> 
    <dt><a href="#class-timed_mutex">Class <code>timed_mutex</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-timed_mutex-synopsis">Class <code>timed_mutex</code> 
        synopsis</a></dt>
      <dt><a href="#class-timed_mutex-ctors">Class <code>timed_mutex</code> constructors 
        and destructor</a></dt>
    </dl>
  </dl>
  <dt><a href="#examples">Example(s)</a></dt>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>Include the header &lt;<a href="../../../boost/thread/mutex.hpp">boost/thread/mutex.hpp</a>&gt; 
  to define the <code><a href="#mutex Synopsis">mutex</a></code>, <code><a href=
        "#try_mutex Synopsis">try_mutex</a></code> and <code><a href=
        "#timed_mutex Synopsis">timed_mutex</a></code> classes.</p>
 <p>The <code><a href="#mutex Synopsis">mutex</a></code>, <code><a href=
        "#try_mutex Synopsis">try_mutex</a></code> and <code><a href=
        "#timed_mutex Synopsis">timed_mutex</a></code> classes are models of <a href="mutex_concept.html#Mutex-concept">Mutex</a>, 
  <a href="mutex_concept.html#TryMutex-concept">TryMutex</a>, and <a href="mutex_concept.html#TimedMutex-concept">TimedMutex</a> 
  respectively. These types should be used to non-recursively synchronize access 
  to shared resources. For recursive locking mechanics, see the <a href="recursive_mutex.html">recursive 
  mutexes</a> supplied by <b>Boost.Threads</b>.</p>
 <p>Each class supplies one or more typedefs for lock types which model matching 
  lock concepts. For the best possible performance you should use the mutex class 
  that supports the minimum set of lock types that you need.</p>
 <table summary="lock types" border="1" cellpadding="5">
  <tr> 
    <td><b>Mutex Class</b></td>
    <td><b>Lock name</b></td>
    <td><b>Lock Concept</b></td>
  </tr>
  <tr> 
    <td valign="top"><a href="#mutex Synopsis"><code> mutex</code></a></td>
    <td valign="middle"><code>scoped_lock</code></td>
    <td valign="middle"><a href="lock_concept.html#ScopedLock"> ScopedLock</a></td>
  </tr>
  <tr> 
    <td valign="top"><code><a href="#try_mutex Synopsis"> try_mutex</a></code> 
    </td>
    <td valign="middle"><code>scoped_lock<br>
      scoped_try_lock</code></td>
    <td valign="middle"><a href="lock_concept.html#ScopedLock"> ScopedLock</a><br>
      <a href="lock_concept.html#ScopedTryLock"> ScopedTryLock</a></td>
  </tr>
  <tr> 
    <td valign="top"><code><a href="#timed_mutex Synopsis"> timed_mutex</a></code> 
    </td>
    <td valign="middle"><code>scoped_lock<br>
      scoped_try_lock<br>
      scoped_timed_lock</code></td>
    <td valign="middle"><a href="lock_concept.html#ScopedLock"> ScopedLock</a><br>
      <a href="lock_concept.html#ScopedTryLock"> ScopedTryLock</a><br>
      <a href="lock_concept.html#ScopedTimedLock"> ScopedTimedLock</a></td>
  </tr>
 </table>
 <p>The <code>mutex</code>, <code>try_mutex</code> and <code>timed_mutex</code> 
  classes use an <code>Unspecified</code> <a href="mutex_concept.html#LockingStrategies">locking 
  strategy</a>, so attempts to recursively lock them or attempts to unlock them 
  by threads that don&#39;t own a lock on them result in <b>undefined behavior</b>. 
  This strategy allows implementations to be as efficient as possible on any given 
  platform. It is, however, recommended that implementations include debugging 
  support to detect misuse when <code>NDEBUG</code> is not defined.</p>
 <p>Like all the <b>Boost.Threads</b> <a href="mutex_concept.html">mutex models</a>, 
  the <code>mutex</code>, <code>try_mutex</code> and <code> timed_mutex</code> 
  leave the <a href="mutex_concept.html#SchedulingPolicies">scheduling policy</a> 
  as <code> Unspecified</code>. Programmers should make no assumptions about the 
  order in which waiting threads acquire a lock.</p>
 <h2><a name="classes"></a>Classes</h2>
 <h3><a name="class-mutex"></a>Class <code>mutex</code></h3>
 <p>The <code>mutex</code> class is a model of <a href="mutex_concept.html#Mutex-concept">Mutex</a> 
  and <a href="overview.html#non-copyable">NonCopyable</a>, and provides no additional 
  facilities beyond the requirements of these concepts.</p>
 <h4><a name="class-mutex-synopsis"></a>Class <code>mutex</code> synopsis</h4>
 <pre>
 namespace boost
 {
    class mutex : private <a href="../../utility/utility.htm">boost::noncopyable</a> // Exposition only.
        // Class mutex meets the <a href="overview.html#non-copyable">NonCopyable</a> requirement.
    {
    public:
        typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
        mutex();
        ~mutex();
    };
 };
 </pre>
 <h4><a name="class-mutex-ctors"></a>Class <code>mutex</code> constructors and 
  destructor</h4>
 <pre>
 mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Postconditions:</b> <code>*this</code> is in an unlocked state.</dt>
 </dl>
 <pre>
 ~mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>*this</code> is in an unlocked sate.</dt>
  <dt><b>Danger:</b> Destruction of a locked mutex is a serious programming error 
    resulting in undefined behavior such as a program crash.</dt>
 </dl>
 <h3><a name="class-try_mutex"></a>Class <code>try_mutex</code></h3>
 <p>The <code>try_mutex</code> class is a model of <a href="mutex_concept.html#TryMutex-concept">TryMutex</a> 
  and <a href="overview.html#non-copyable">NonCopyable</a>, and provides no additional 
  facilities beyond the requirements of these concepts.</p>
 <h4><a name="class-try_mutex-synopsis"></a>Class <code>try_mutex</code> synopsis</h4>
 <pre>
 namespace boost
 {
    class try_mutex : private <a href="../../utility/utility.htm">boost::noncopyable</a> // Exposition only.
        // Class try_mutex meets the <a href="overview.html#non-copyable">NonCopyable</a> requirement.
    {
    Public:
        typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
        typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_try_lock;
        try_mutex();
        ~try_mutex();
    };
 };
 </pre>
 <h4><a name="class-try_mutex-ctors"></a>Class <code>try_mutex</code> constructors 
  and destructor</h4>
 <pre>
 try_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Postconditions:</b> <code>*this</code> is in an unlocked state.</dt>
 </dl>
 <pre>
 ~try_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>*this</code> is in an unlocked sate.</dt>
  <dt><b>Danger:</b> Destruction of a locked mutex is a serious programming error 
    resulting in undefined behavior such as a program crash.</dt>
 </dl>
 <h3><a name="class-timed_mutex"></a>Class <code>timed_mutex</code></h3>
 <p>The <code>timed_mutex</code> class is a model of <a href="mutex_concept.html#TimedMutex-concept">TimedMutex</a> 
  and <a href="overview.html#non-copyable">NonCopyable</a>, and provides no additional 
  facilities beyond the requirements of these concepts.</p>
 <h4><a name="class-timed_mutex-synopsis"></a>Class <code>timed_mutex</code> synopsis</h4>
 <pre>
 namespace boost
 {
    class timed_mutex : private <a href="../../utility/utility.htm">boost::noncopyable</a> // Exposition only.
        // Class timed_mutex meets the <a href="overview.html#non-copyable">NonCopyable</a> requirement.
    {
    Public:
        typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_lock;
        typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_try_lock;
        typedef <i>[implementation defined; see <a href="#Introduction">Introduction</a>]</i> scoped_timed_lock;
        timed_mutex();
        ~timed_mutex();
    };
 };
 </pre>
 <h4><a name="class-timed_mutex-ctors"></a>Class <code>timed_mutex</code> constructors 
  and destructor</h4>
 <pre>
 timed_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Postconditions:</b> <code>*this</code> is in an unlocked state.</dt>
 </dl>
 <pre>
 ~timed_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>*this</code> is in an unlocked sate.</dt>
  <dt><b>Danger:</b> Destruction of a locked mutex is a serious programming error 
    resulting in undefined behavior such as a program crash.</dt>
 </dl>
 <h2><a name="examples"></a>Example(s)</h2>
 <pre>
 #include <a href=
 "../../../boost/thread/mutex.hpp">&lt;boost/thread/mutex.hpp&gt;</a>
 #include <a href=
 "../../../boost/thread/thread.hpp">&lt;boost/thread/thread.hpp&gt;</a>
 #include &lt;iostream&gt;
 boost::mutex io_mutex; // The iostreams are not guaranteed to be <a href=
 "definitions.html#Thread-safe">thread-safe</a>!
 class counter
 {
 public:
    counter() : count(0) { }
    int increment() {
        boost::mutex::scoped_lock scoped_lock(mutex);
        return ++count;
    }
 private:
    boost::mutex mutex;
    int count;
 };
 counter c;
 void change_count()
 {
    int i = c.increment();
    boost::mutex::scoped_lock scoped_lock(io_mutex);
    std::cout &lt;&lt; &quot;count == &quot; &lt;&lt; i &lt;&lt; std::endl;
 }
 int main(int, char*[])
 {
    const int num_threads = 4;
    boost::thread_group thrds;
    for (int i=0; i &lt; num_threads; ++i)
        thrds.create_thread(&amp;change_count);
    thrds.join_all();
    return 0;
 }
 </pre>
 <p>The output is:</p>
 <pre>
 count == 1
 count == 2
 count == 3
 count == 4
 </pre>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/mutex_concept.html
+++ b/doc/mutex_concept.html
@@ -0,0 +1,239 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Mutex Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> <a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a> 
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Mutex Concept</h2>
    </td>
  </tr>
 </table>
 <hr>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#locking-strategies">Locking Strategies</a></dt>
  <dl class="page-index"> 
    <dt><a href="#locking-strategy-recursive">Recursive</a></dt>
    <dt><a href="#locking-strategy-checked">Checked</a></dt>
    <dt><a href="#locking-strategy-unchecked">Unchecked</a></dt>
    <dt><a href="#locking-strategy-unspecified">Unspecified</a></dt>
  </dl>
  <dt><a href="#scheduling-policies">Scheduling Policies</a></dt>
  <dl class="page-index"> 
    <dt><a href="#scheduling-policy-FIFO">FIFO</a></dt>
    <dt><a href="#scheduling-policy-priority-driven">Priority Driven</a></dt>
    <dt><a href="#scheduling-policy-unspecified">Unspecified</a></dt>
  </dl>
  <dt><a href="#concept-requirements">Concept Requirements</a></dt>
  <dl class="page-index"> 
    <dt><a href="#Mutex-concept">Mutex Concept</a></dt>
    <dt><a href="#TryMutex-concept">TryMutex Concept</a></dt>
    <dt><a href="#TimedMutex-concept">TimedMutex Concept</a></dt>
  </dl>
  <dt><a href="#models">Models</a></dt>
 </dl>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>A mutex (short for mutual-exclusion) object is used to serializes access to 
  a resource shared between multiple threads. The <a href="#Mutex">Mutex</a> concept, 
  with <a href="#TryMutex">TryMutex</a> and <a href="#TimedMutex">TimedMutex</a> 
  refinements, formalize the requirements. A model that implements Mutex and its 
  refinements has two states: <b>locked</b> and <b>unlocked</b>. Before using 
  a shared resource, a thread locks a <b>Boost.Threads</b> mutex object (an object 
  whose type is a model of <a href="#Mutex-concept">Mutex</a> or one of it's 
  refinements), insuring <a href="definitions.html#thread-safe">thread-safe</a> 
  access to the shared resource. When use of the shared resource is complete, 
  the thread unlocks the mutex object, allowing another thread to acquire the 
  lock and use the shared resource.</p>
 <p>Traditional C thread APIs, like POSIX threads or the Windows thread APIs, expose 
  functions to lock and unlock a mutex object. This is dangerous since it&#39;s 
  easy to forget to unlock a locked mutex. When the flow of control is complex, 
  with multiple return points, the likelihood of forgetting to unlock a mutex 
  object would become even greater. When exceptions are thrown, it becomes nearly 
  impossible to ensure that the mutex object is unlocked properly when using these 
  traditional API&#39;s. The result is <a href="definitions.html#deadlock">deadlock</a>.</p>
 <p>Many C++ threading libraries use a pattern known as <i>Scoped Locking</i> <a href="bibliography.html#Schmidt-00">[Schmidt 
  00]</a> to free the programmer from the need to explicitly lock and unlock mutex 
  objects. With this pattern, a <a href="lock_concept.html">Lock</a> concept is 
  employed where the lock object&#39;s constructor locks the associated mutex 
  object and the destructor automatically does the unlocking. The <b>Boost.Threads</b> 
  library takes this pattern to the extreme in that Lock concepts are the only 
  way to lock and unlock a mutex object: lock and unlock functions are not exposed 
  by any <b>Boost.Threads</b> mutex objects. This helps to ensure safe usage patterns, 
  especially when code throws exceptions.</p>
 <h2><a name="locking-strategies"></a>Locking Strategies</h2>
 <p>Every mutex object follows one of several locking strategies. These strategies 
  define the semantics for the locking operation when the calling thread already 
  owns a lock on the mutex object.</p>
 <h3><a name="locking-strategy-recursive"></a>Recursive</h3>
 <p>With a recursive locking strategy when a thread attempts to acquire a lock 
  on the mutex object for which it already owns a lock, the operation is successful. 
  Note the distinction between a thread, which may have multiple locks outstanding 
  on a recursive mutex object, and a lock object, which even for a recursive mutex 
  object cannot have any of its lock functions called multiple times without first 
  calling unlock.</p>
 <p>Internally a lock count is maintained and the owning thread must unlock the 
  mutex model the same number of times that it&#39;s locked it before the mutex 
  object&#39;s state returns to unlocked. Since mutex objects in <b>Boost.Threads</b> 
  expose locking functionality only through lock concepts, a thread will always 
  unlock a mutex object the same number of times that it locked it. This helps 
  to eliminate a whole set of errors typically found in traditional C style thread 
  APIs.</p>
 <p>Classes <a href="recursive_mutex.html#class-recursive_mutex">recursive_mutex</a>, 
  <a href="recursive_mutex.html#class-recursive_try_mutex">recursive_try_mutex</a> 
  and <a href="recursive_mutex.html#class-recursive_timed_mutex">recursive_timed_mutex</a> 
  use this locking strategy.</p>
 <h3><a name="locking-strategy-checked"></a>Checked</h3>
 <p>With a checked locking strategy when a thread attempts to acquire a lock on 
  the mutex object for which the thread already owns a lock, the operation will 
  fail with some sort of error indication. Further, attempts by a thread to unlock 
  a mutex object that was not locked by the thread will also return some sort 
  of error indication. In <b>Boost.Threads</b>, an exception of type <a href="exceptions.html#class-lock_error"> 
  lock_error</a> would be thrown in these cases.</p>
 <p><b>Boost.Threads</b> does not currently provide any mutex objects that use 
  this strategy.</p>
 <h3><a name="locking-strategy-unchecked"></a>Unchecked</h3>
 <p>With an unchecked locking strategy when a thread attempts to acquire a lock 
  on a mutex object for which the thread already owns a lock the operation will 
  <a href="definitions.html#definition-deadlock">deadlock</a>. In general this 
  locking strategy is less safe than a checked or recursive strategy, but it&#39;s 
  also a faster strategy and so is employed by many libraries.</p>
 <p><b>Boost.Threads</b> does not currently provide any mutex objects that use 
  this strategy.</p>
 <h3><a name="locking-strategy-unspecified"></a>Unspecified</h3>
 <p>With an unspecified locking strategy, when a thread attempts to acquire a lock 
  on a mutex object for which the thread already owns a lock the operation results 
  in <b>undefined behavior</b>.</p>
 <p>In general a mutex object with an unspecified locking strategy is unsafe, and 
  it requires programmer discipline to use the mutex object properly. However, 
  this strategy allows an implementation to be as fast as possible with no restrictions 
  on its implementation. This is especially true for portable implementations 
  that wrap the native threading support of a platform. For this reason, the classes 
  <a href="mutex.html#class-mutex">mutex</a>, <a href="mutex.html#class-try_mutex">try_mutex</a> 
  and <a href="mutex.html#class-timed_mutex">timed_mutex</a> use this locking 
  strategy despite the lack of safety.</p>
 <h2><a name="scheduling-policies"></a>Scheduling Policies</h2>
 <p>Every mutex object follows one of several scheduling policies. These policies 
  define the semantics when the mutex object is unlocked and there is more than 
  one thread waiting to acquire a lock. In other words, the policy defines which 
  waiting thread shall acquire the lock.</p>
 <h3><a name="scheduling-policy-FIFO"></a>FIFO</h3>
 <p>With a FIFO scheduling policy, threads waiting for the lock will acquire it 
  in a first come first serve order (or First In First Out). This can help prevent 
  a high priority thread from starving lower priority threads that are also waiting 
  on the mutex object's lock.</p>
 <h3><a name="scheduling-policy-priority-driven"></a>Priority Driven</h3>
 <p>With a Priority Driven scheduling policy, the thread with the highest priority 
  acquires the lock. Note that this means that low-priority threads may never 
  acquire the lock if the mutex object has high contention and there is always 
  at least one high-priority thread waiting. This is known as thread starvation. 
  When multiple threads of the same priority are waiting on the mutex object's 
  lock one of the other scheduling priorities will determine which thread shall 
  acquire the lock.</p>
 <h3><a name="scheduling-policy-unspecified"></a>Unspecified</h3>
 <p>The mutex object does not specify a scheduling policy. In order to ensure portability, 
  all <b>Boost.Threads</b> mutex models use an unspecified scheduling policy.</p>
 <h2><a name="concept-requirements"></a>Concept Requirements</h2>
 <h3><a name="Mutex-concept"></a>Mutex Concept</h3>
 <p>A Mutex object has two states: locked and unlocked. Mutex object state can 
  only be determined by an object meeting the <a href="lock_concept.html#ScopedLock">ScopedLock</a> 
  requirements and constructed for the Mutex object.</p>
 <p>A Mutex is <a href="../../utility/utility.htm#Class noncopyable">NonCopyable</a>.</p>
 <p>For a Mutex type M and an object m of that type, the following expressions 
  must be well-formed and have the indicated effects.</p>
 <table summary="Mutex expressions" border="1" cellpadding="5">
  <tr> 
    <td><b>Expression</b></td>
    <td><b>Effects</b></td>
  </tr>
  <tr> 
    <td><code>M m;</code></td>
    <td>Constructs a mutex object m. Post-condition: m is unlocked.</td>
  </tr>
  <tr> 
    <td><code>(&amp;m)-&gt;~M();</code></td>
    <td>Precondition: m is unlocked. Destroys a mutex object m.</td>
  </tr>
  <tr> 
    <td><code>M::scoped_lock</code></td>
    <td>A model of <a href="lock_concept.html#ScopedLock">ScopedLock</a>.</td>
  </tr>
 </table>
 <h3><a name="TryMutex-concept"></a>TryMutex Concept</h3>
 <p>A TryMutex is a refinement of <a href="#Mutex-concept">Mutex</a>. For a TryMutex 
  type M and an object m of that type, the following expressions must be well-formed 
  and have the indicated effects.</p>
 <table summary="TryMutex expressions" border="1" cellpadding="5">
  <tr> 
    <td><b>Expression</b></td>
    <td><b>Effects</b></td>
  </tr>
  <tr> 
    <td><code>M::scoped_try_lock</code></td>
    <td>A model of <a href="lock_concept.html#ScopedTryLock">ScopedTryLock</a>.</td>
  </tr>
 </table>
 <h3><a name="TimedMutex-concept"></a>TimedMutex Concept</h3>
 <p>A TimedMutex is a refinement of <a href="#TryMutex-concept">TryMutex</a>. For 
  a TimedMutex type M and an object m of that type, the following expressions 
  must be well-formed and have the indicated effects.</p>
 <table summary="TimedMutex expressions" border="1" cellpadding="5">
  <tr> 
    <td><b>Expression</b></td>
    <td><b>Effects</b></td>
  </tr>
  <tr> 
    <td><code>M::scoped_timed_lock</code></td>
    <td>A model of <a href="lock_concept.html#ScopedTimedLock">ScopedTimedLock</a>.</td>
  </tr>
 </table>
 <h2><a name="models"></a>Models</h2>
 <p><b>Boost.Threads</b> currently supplies six models of Mutex.</p>
 <table summary="Mutex concept classes" border="1" cellpadding="5">
  <tr> 
    <td><b>Concept</b></td>
    <td><b>Refines</b></td>
    <td><b>Models</b></td>
  </tr>
  <tr> 
    <td valign="top"><a href="#Mutex-concept">Mutex</a></td>
    <td valign="top">&nbsp;</td>
    <td><a href="mutex.html">mutex</a><br>
      <a href="recursive_mutex.html">recursive_mutex</a></td>
  </tr>
  <tr> 
    <td valign="top"><a href="#TryMutex-concept">TryMutex</a></td>
    <td valign="top"><a href="#Mutex-concept">Mutex</a></td>
    <td><a href="mutex.html">try_mutex<br>
      </a> <a href="recursive_mutex.html">recursive_try_mutex</a> </td>
  </tr>
  <tr> 
    <td valign="top"><a href="#TimedMutex-concept">TimedMutex</a></td>
    <td valign="top"><a href="#TryMutex-concept">TryMutex</a></td>
    <td><a href="mutex.html">timed_mutex<br>
      </a> <a href="recursive_mutex.html"> recursive_timed_mutex</a></td>
  </tr>
 </table>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/once.html
+++ b/doc/once.html
@@ -0,0 +1,116 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Header &lt;boost/thread/once.hpp&gt;</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Header &lt;<a href="../../../boost/thread/once.hpp">boost/thread/once.hpp</a>&gt;</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#macros">Macros</a></dt>
  <dl class="page-index"> 
    <dt><a href="#macro-BOOST_ONCE_INIT">BOOST_ONCE_INIT</a></dt>
  </dl>
  <dt><a href="#types">Types</a></dt>
  <dl class="page-index"> 
    <dt><a href="#type-once_flag">once_flag</a></dt>
  </dl>
  <dt><a href="#functions">Functions</a></dt>
  <dl class="page-index"> 
    <dt><a href="#function-call_once">call_once</a></dt>
  </dl>
  <dt><a href="#examples">Example(s)</a></dt>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>Include the header &lt;<a href="../../../boost/thread/once.hpp">boost/thread/once.hpp</a>&gt; 
  to define the <code>call_once</code> function, <code>once_flag</code> type and 
  <code>BOOST_ONCE_INIT</code> constant.</p>
 <p>The <code>call_once</code> function and <code>once_flag</code> type (statically 
  initialized to <code>BOOST_ONCE_INIT</code>) can be used to run a routine exactly 
  once. This can be used to initialize data in a <a href="definitions.html#Thread-safe"> 
  thread-safe</a> manner.</p>
 <h2><a name="macros"></a>Macros</h2>
 <pre>
 <a name="macro-BOOST_ONCE_INIT"></a>#define BOOST_ONCE_INIT <i>implementation defined</i>
 </pre>
 <p>This is a constant value used to initialize <code>once_flag</code> instances 
  to indicate that the logically associated routine has not been run yet.</p>
 <h2><a name="types"></a>Types</h2>
 <pre>
 <a name="type-once_flag"></a>typedef <i>implementation defined</i> once_flag;
 </pre>
 <p>This implementation defined type is used as a flag to insure a routine is called 
  only once. Instances of this type should be statically initialized to <code>BOOST_ONCE_INIT</code>.</p>
 <h2><a name="functions"></a>Functions</h2>
 <pre>
 <a name="function-call_once"></a>void call_once(void (*func)(), once_flag& flag);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> The function <code>func</code> shall not throw exceptions.</dt>
  <dt><b>Effects:</b> As if (in an atomic fashion): 
    <pre>
 if (flag == BOOST_ONCE_INIT)
    func();
 </pre>
  </dt>
  <dt><b>Postconditions:</b> <code>flag != BOOST_ONCE_INIT</code></dt>
 </dl>
 <h2><a name="examples"></a>Example(s)</h2>
 <pre>
 #include <a href="../../../boost/thread/thread.hpp">&lt;boost/thread/thread.hpp&gt;</a>
 #include <a href="../../../boost/thread/tss.hpp">&lt;boost/thread/once.hpp&gt;</a>
 #include &lt;cassert&gt;
 int value=0;
 boost::once_flag once = BOOST_ONCE_INIT;
 void init()
 {
    ++value;
 }
 void thread_proc()
 {
   boost::call_once(&amp;init, once);
 }
 int main(int argc, char* argv[])
 {
   boost::thread_group threads;
   for (int i=0; i&lt;5; ++i)
      threads.create_thread(&amp;thread_proc);
   threads.join_all();
   assert(value == 1);
 }
 </pre>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/overview.html
+++ b/doc/overview.html
@@ -0,0 +1,173 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Overview</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Overview</h2>
    </td>
  </tr>
 </table>
 <hr>
 <dl class="index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#dangers">Dangers</a></dt>
  <dl class="index"> 
    <dt><a href="#testing-debugging">Testing and debugging considerations</a></dt>
    <dt><a href="#head-start">Getting a head start</a></dt>
  </dl>
  <dt><a href="#library">C++ Standard Library usage in multithreaded programs</a></dt>
  <dl class="index"> 
    <dt><a href="#runtime-libraries">Runtime libraries</a></dt>
    <dt><a href="#non-thread-safe-functions">Potentially non-thread-safe functions</a></dt>
  </dl>
  <dt><a href="#common-requirements">Common requirements for all Boost.Threads 
    components</a></dt>
  <dl class="index"> 
    <dt><a href="#exceptions">Exceptions</a></dt>
    <dt><a href="#non-copyable">NonCopyable requirement</a></dt>
  </dl>
 </dl>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>Boost.Threads allows C++ programs to execute as multiple, asynchronous, independent, 
  threads-of-execution. Each thread has its own machine state including program 
  instruction counter and registers. Programs which execute as multiple threads 
  are called multithreaded programs to distinguish them from traditional single-threaded 
  programs. <a href="definitions.html">Definitions</a> gives a more complete description 
  of the multithreading execution environment.</p>
 <p>Multithreading provides several advantages:</p>
 <ul>
  <li>Programs which would otherwise block waiting for some external event can 
    continue to respond if the blocking operation is placed in a separate thread. 
    Multithreading is usually an absolute requirement for these programs.</li>
 </ul>
 <ul>
  <li>Well-designed multithreaded programs may execute faster than single-threaded 
    programs, particularly on multiprocessor hardware. Note, however, that poorly-designed 
    multithreaded programs are often slower that single-threaded programs.</li>
 </ul>
 <ul>
  <li>Some program designs may be easier to formulate using a multithreaded approach. 
    After all, the real world is asynchronous!</li>
 </ul>
 <h2><a name="dangers"></a>Dangers</h2>
 <p>Beyond the errors which can occur in single-threaded programs, multithreaded 
  programs are subject to additional errors:</p>
 <ul>
  <li><a href="definitions.html#definition-race-condition">Race conditions</a>.</li>
  <li><a href="definitions.html#definition-deadlock">Deadlock</a> (sometimes called 
    &quot;deadly embrace&quot;)</li>
  <li><a href="definitions.html#definition-priority-failure">Priority failures</a> 
    (priority inversion, infinite overtaking, starvation, etc.)</li>
 </ul>
 <p>Every multithreaded program must be designed carefully to avoid race conditions, 
  priority failures and deadlock. These aren&#39;t rare or exotic failures - they 
  are virtually guaranteed to occur unless multithreaded code is designed to avoid 
  them. Priority failures are somewhat less common, but are nonetheless serious.</p>
 <p>The <a href="introduction.html">Boost.Threads design</a> attempts to minimize 
  these errors, but they will still occur unless the programmer proactively designs 
  to avoid them.</p>
 <h3><a name="testing-debugging"></a>Testing and debugging considerations</h3>
 <p>Multithreaded programs are non-deterministic. In other words, the same program 
  with the same input data may follow different execution paths each time it is 
  invoked. That can make testing and debugging a nightmare:</p>
 <ul>
  <li>Failures are often not repeatable.</li>
  <li>Probe effect causes debuggers to produce very different results from non-debug 
    uses.</li>
  <li>Debuggers require special support to show thread state.</li>
  <li>Tests on a single processor system may give no indication of serious errors 
    which would appear on multiprocessor systems, and visa versa. Thus test cases 
    should include a varying number of processors.</li>
  <li>For programs which create a varying number of threads according to workload, 
    tests which don&#39;t span the full range of possibilities may miss serious 
    errors.</li>
 </ul>
 <h3><a name="head-start"></a>Getting a head start</h3>
 <p>Although it might appear that multithreaded programs are inherently unreliable, 
  many reliable multithreaded programs do exist. Multithreading techniques are 
  known which lead to reliable programs.</p>
 <p>Design patterns for reliable multithreaded programs, including the important 
  <i>monitor</i> pattern, are presented in <cite> Pattern-Oriented Software Architecture 
  Volume 2 - Patterns for Concurrent and Networked Objects</cite> [<a href=
        "bibliography.html#Schmidt-00">Schmidt 00</a>]. Many important multithreading 
  programming considerations (independent of threading library) are discussed 
  in <cite>Programming with POSIX Threads</cite> [<a href="bibliography.html#Butenhof-97">Butenhof 
  97</a>].</p>
 <p>Doing some reading before attempting multithreaded designs will give you a 
  head start toward reliable multithreaded programs.</p>
 <h2><a name="library"></a>C++ Standard Library usage in multithreaded programs</h2>
 <h3><a name="runtime-libraries"></a>Runtime libraries</h3>
 <p><b>Warning:</b> Multithreaded programs such as those using <b> Boost.Threads</b> 
  must link to <a href="definitions.html#Thread-safe"> thread-safe</a> versions 
  of all runtime libraries used by the program, including the runtime library 
  for the C++ Standard Library. Otherwise <a href="definitions.html#Race condition">race 
  conditions</a> will occur when multiple threads simultaneously execute runtime 
  library functions for <i>new</i>, <i>delete</i>, or other language features 
  which imply shared state.</p>
 <h3><a name="non-thread-safe-functions"></a>Potentially non-thread-safe functions</h3>
 <p>Certain C++ Standard Library functions inherited from C are particular problems 
  because they hold internal state between calls:</p>
 <ul>
  <li>rand</li>
  <li>strtok</li>
  <li>asctime</li>
  <li>ctime</li>
  <li>gmtime</li>
  <li>localtime</li>
 </ul>
 <p>It is possible to write thread-safe implementations of these by using <a href="tss.html#class-thread_specific_ptr">thread-specific 
  storage</a>, and several C++ compiler vendors do just that. The technique is 
  well-know and is explained in [<a href=
        "bibliography.html#Butenhof-97">Buttenhof 97</a>].</p>
 <p>But at least one vendor (HP-UX) does not provide thread-safe implementations 
  of the above functions in their otherwise thread-safe runtime library. Instead 
  they provide replacement functions with different names and arguments.</p>
 <p><b>Recommendation:</b> For the most portable, yet thread-safe code, use Boost 
  replacements for the problem functions. See the <a href=
        "../../random/index.html">Boost Random Number Library</a> and <a href=
        "../../tokenizer/index.htm">Boost Tokenizer Library</a>.</p>
 <h2><a name="common-gaurantees"></a>Common guarantees for all Boost.Threads components</h2>
 <h3><a name="exceptions"></a>Exceptions</h3>
 <p><b>Boost.Threads</b> destructors never throw exceptions. Unless otherwise specified, 
  other <b>Boost.Threads</b> functions that do not have an exception-specification 
  may throw implementation-defined exceptions.</p>
 <p>In particular, <b>Boost.Threads</b> reports failure to allocate storage by 
  throwing an exception of type std::bad_alloc, or a class derived from std::bad_alloc, 
  failure to obtain thread resources other than memory by throwing an exception 
  of type <a href="exceptions.html#class-thread_resource_error">boost::thread_resource_error</a>, 
  and certain lock related failures by throwing an exception of type <a href="exceptions.html#class-lock_error">boost::lock_error</a></p>
 <p><b>Rationale:</b> Follows the C++ Standard Library practice of allowing all 
  functions except destructors or other specified functions to throw exceptions 
  on errors.</p>
 <h3><a name="non-copyable"></a>NonCopyable requirement</h3>
 <p><b>Boost.Threads</b> classes documented as meeting the NonCopyable requirement 
  disallow copy construction and copy assignment. For the sake of exposition, 
  the synopsis of such classes show private derivation from <a href="../../utility/utility.htm"> 
  boost::noncopyable</a>. Users should not depend on this derivation, however, 
  as implementations are free to meet the NonCopyable requirement in other ways.</p>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/rationale.html
+++ b/doc/rationale.html
@@ -0,0 +1,399 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Rationale</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Rationale</h2>
    </td>
  </tr>
 </table>
 <hr>
 <dl class="index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#library">Rationale for the Creation of <b>Boost.Threads</b></a></dt>
  <dt><a href="#primitives">Rationale for the Low Level Primitives Supported in 
    <b>Boost.Threads</b></a></dt>
  <dt><a href="#lock_objects">Rationale for the Lock Design</a></dt>
  <dt><a href="#non-copyable">Rationale for NonCopyable Thread Type</a></dt>
  <dt><a href="#events">Rationale for not providing <i>Event Variables</i></a></dt>
 </dl>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>This page explains the rationale behind various design decisions in the <b>Boost.Threads</b> 
  library. Having the rationale documented here should explain how we arrived 
  at the current design as well as prevent future rehashing of discussions and 
  thought processes that have already occurred. It can also give users a lot of 
  insight into the design process required for this library.</p>
 <h2><a name="library"></a>Rationale for the Creation of <b>Boost.Threads</b></h2>
 <p>Processes often have a degree of &quot;potential parallelism&quot; and it can 
  often be more intuitive to design systems with this in mind. Further, these 
  parallel processes can result in more responsive programs. The benefits for 
  multithreaded programming are quite well known to most modern programmers, yet 
  the C++ language doesn&#39;t directly support this concept.</p>
 <p>Many platforms support multithreaded programming despite the fact that the 
  language doesn&#39;t support it. They do this through external libraries, which 
  are, unfortunately, platform specific. POSIX has tried to address this problem 
  through the standardization of a &quot;pthread&quot; library. However, this 
  is a standard only on POSIX platforms, so its portability is limited.</p>
 <p>Another problem with POSIX and other platform specific thread libraries is 
  that they are almost universally C based libraries. This leaves several C++ 
  specific issues unresolved, such as what happens when an exception is thrown 
  in a thread. Further, there are some C++ concepts, such as destructors, that 
  can make usage much easier than what&#39;s available in a C library.</p>
 <p>What&#39;s truly needed is C++ language support for threads. However, the C++ 
  standards committee needs existing practice or a good proposal as a starting 
  point for adding this to the standard.</p>
 <p>The <b>Boost.Threads</b> library was developed to provide a C++ developer with 
  a portable interface for writing multithreaded programs on numerous platforms. 
  There&#39;s a hope that the library can be the basis for a more detailed proposal 
  for the C++ standards committee to consider for inclusion in the next C++ standard.</p>
 <h2><a name="primitives"></a>Rationale for the Low Level Primitives Supported 
  in <b>Boost.Threads</b></h2>
 <p>The <b>Boost.Threads</b> library supplies a set of low level primitives for 
  writing multithreaded programs, such as mutexes and condition variables. In 
  fact, the first release of <b>Boost.Threads</b> supports only these low level 
  primitives. However, computer science research has shown that use of these primitives 
  is difficult since it's difficult to mathematically prove that a usage pattern 
  is correct, meaning it doesn&#39;t result in race conditions or deadlocks. There 
  are several algebras (such as CSP, CCS and Join calculus) that have been developed 
  to help write provably correct parallel processes. In order to prove the correctness 
  these processes must be coded using higher level abstractions. So why does <b>Boost.Threads</b> 
  support the lower level concepts?</p>
 <p>The reason is simple: the higher level concepts need to be implemented using 
  at least some of the lower level concepts. So having portable lower level concepts 
  makes it easier to develop the higher level concepts and will allow researchers 
  to experiment with various techniques.</p>
 <p>Beyond this theoretical application of higher level concepts, however, the 
  fact remains that many multithreaded programs are written using only the lower 
  level concepts, so they are useful in and of themselves, even if it&#39;s hard 
  to prove that their usage is correct. Since many users will be familiar with 
  these lower level concepts but be unfamiliar with any of the higher level concepts 
  there&#39;s also an argument for accessibility.</p>
 <h2><a name="lock_objects"></a>Rationale for the Lock Design</h2>
 <p>Programmers who are used to multithreaded programming issues will quickly note 
  that the Boost.Thread&#39;s design for mutex lock concepts is not <a href="definitions.html#Thread-safe">thread-safe</a> 
  (this is clearly documented as well). At first this may seem like a serious 
  design flaw. Why have a multithreading primitive that&#39;s not thread-safe 
  itself?</p>
 <p>A lock object is not a synchronization primitive. A lock object&#39;s sole 
  responsibility is to ensure that a mutex is both locked and unlocked in a manner 
  that won&#39;t result in the common error of locking a mutex and then forgetting 
  to unlock it. This means that instances of a lock object are only going to be 
  created, at least in theory, within block scope and won&#39;t be shared between 
  threads. Only the mutex objects will be created outside of block scope and/or 
  shared between threads. Though it&#39;s possible to create a lock object outside 
  of block scope and to share it between threads to do so would not be a typical 
  usage (in fact, to do so would likely be an error). Nor are there any cases 
  when such usage would be required.</p>
 <p>Lock objects must maintain some state information. In order to allow a program 
  to determine if a try_lock or timed_lock was successful the lock object must 
  retain state indicating the success or failure of the call made in its constructor. 
  If a lock object were to have such state and remain thread-safe it would need 
  to synchronize access to the state information which would result in roughly 
  doubling the time of most operations. Worse, since checking the state can occur 
  only by a call after construction we&#39;d have a race condition if the lock 
  object were shared between threads.</p>
 <p>So, to avoid the overhead of synchronizing access to the state information 
  and to avoid the race condition the <b>Boost.Threads</b> library simply does 
  nothing to make lock objects thread-safe. Instead, sharing a lock object between 
  threads results in undefined behavior. Since the only proper usage of lock objects 
  is within block scope this isn&#39;t a problem, and so long as the lock object 
  is properly used there&#39;s no danger of any multithreading issues.</p>
 <h2><a name="non-copyable"></a>Rationale for NonCopyable Thread Type</h2>
 <p>Programmers who are used to C libraries for multithreaded programming are likely 
  to wonder why <b>Boost.Threads</b> uses a noncopyable design for <a href="thread.html">boost::thread</a>. 
  After all, the C thread types are copyable, and you often have a need for copying 
  them within user code. However, careful comparison of C designs to C++ designs 
  shows a flaw in this logic.</p>
 <p>All C types are copyable. It is, in fact, not possible to make a noncopyable 
  type in C. For this reason types that represent system resources in C are often 
  designed to behave very similarly to a pointer to dynamic memory. There&#39;s 
  an API for acquiring the resource and an API for releasing the resources. For 
  memory we have pointers as the type and alloc/free for the acquisition and release 
  APIs. For files we have FILE* as the type and fopen/fclose for the acquisition 
  and release APIs. You can freely copy instances of the types but must manually 
  manage the lifetime of the actual resource through the acquisition and release 
  APIs.</p>
 <p>C++ designs recognize that the acquisition and release APIs are error prone 
  and try to eliminate possible errors by acquiring the resource in the constructor 
  and releasing it in the destructor. The best example of such a design is the 
  std::iostream set of classes which can represent the same resource as the FILE* 
  type in C. A file is opened in the std::fstream&#39;s constructor and closed 
  in its destructor. However, if an iostream were copyable it could lead to a 
  file being closed twice, an obvious error, so the std::iostream types are noncopyable 
  by design. This is the same design used by boost::thread, which is a simple 
  and easy to understand design that&#39;s consistent with other C++ standard 
  types.</p>
 <p>During the design of boost::thread it was pointed out that it would be possible 
  to allow it to be a copyable type if some form of &quot;reference management&quot; 
  were used, such as ref-counting or ref-lists, and many argued for a boost::thread_ref 
  design instead. The reasoning was that copying &quot;thread&quot; objects was 
  a typical need in the C libraries, and so presumably would be in the C++ libraries 
  as well. It was also thought that implementations could provide more efficient 
  reference management than wrappers (such as boost::shared_ptr) around a noncopyable 
  thread concept. Analysis of whether or not these arguments would hold true doesn&#39;t 
  appear to bear them out. To illustrate the analysis we&#39;ll first provide 
  pseudo-code illustrating the six typical usage patterns of a thread object.</p>
 <h3>1. Simple creation of a thread.</h3>
 <pre>
 void foo()
 {
   create_thread(&amp;bar);
 }
 </pre>
 <h3>2. Creation of a thread that's later joined.</h3>
 <pre>
 Void foo()
 {
   thread = create_thread(&amp;bar);
   join(thread);
 }
 </pre>
 <h3>3. Simple creation of several threads in a loop.</h3>
 <pre>
 Void foo()
 {
   for (int i=0; i&lt;NUM_THREADS; ++i)
      create_thread(&amp;bar);
 }
 </pre>
 <h3>4. Creation of several threads in a loop which are later joined.</h3>
 <pre>
 Void foo()
 {
   for (int i=0; i&lt;NUM_THREADS; ++i)
      threads[i] = create_thread(&amp;bar);
   for (int i=0; i&lt;NUM_THREADS; ++i)
      threads[i].join();
 }
 </pre>
 <h3>5. Creation of a thread whose ownership is passed to another object/method.</h3>
 <pre>
 Void foo()
 {
   thread = create_thread(&amp;bar);
   manager.owns(thread);
 }
 </pre>
 <h3>6. Creation of a thread whose ownership is shared between multiple objects.</h3>
 <pre>
 Void foo()
 {
   thread = create_thread(&amp;bar);
   manager1.add(thread);
   manager2.add(thread);
 }
 </pre>
 <p>Of these usage patterns there&#39;s only one that requires reference management 
  (number 6). Hopefully it&#39;s fairly obvious that this usage pattern simply 
  won&#39;t occur as often as the other usage patterns. So there really isn&#39;t 
  a &quot;typical need&quot; for a thread concept, though there is some need.</p>
 <p>Since the need isn&#39;t typical we must use different criteria for deciding 
  on either a thread_ref or thread design. Possible criteria include ease of use 
  and performance. So let&#39;s analyze both of these carefully.</p>
 <p>With ease of use we can look at existing experience. The standard C++ objects 
  that represent a system resource, such as std::iostream, are noncopyable, so 
  we know that C++ programmers must at least be experienced with this design. 
  Most C++ developers are also used to smart pointers such as boost::shared_ptr, 
  so we know they can at least adapt to a thread_ref concept with little effort. 
  So existing experience isn&#39;t going to lead us to a choice.</p>
 <p>The other thing we can look at is how difficult it is to use both types for 
  the six usage patterns above. If we find it overly difficult to use a concept 
  for any of the usage patterns there would be a good argument for choosing the 
  other design. So we&#39;ll code all six usage patterns using both designs.</p>
 <h3>1.</h3>
 <pre>
 void foo()
 {
   thread thrd(&amp;bar);
 }
 void foo()
 {
   thread_ref thrd = create_thread(&amp;bar);
 }
 </pre>
 <h3>2.</h3>
 <pre>
 void foo()
 {
   thread thrd(&amp;bar);
   thrd.join();
 }
 void foo()
 {
   thread_ref thrd = 
   create_thread(&amp;bar);thrd-&gt;join();
 }
 </pre>
 <h3>3.</h3>
 <pre>
 void foo()
 {
   for (int i=0; i&lt;NUM_THREADS; ++i)
      thread thrd(&amp;bar);
 }
 void foo()
 {
   for (int i=0; i&lt;NUM_THREADS; ++i)
      thread_ref thrd = create_thread(&amp;bar);
 }
 </pre>
 <h3>4.</h3>
 <pre>
 void foo()
 {
   std::auto_ptr&lt;thread&gt; threads[NUM_THREADS];
   for (int i=0; i&lt;NUM_THREADS; ++i)
      threads[i] = std::auto_ptr&lt;thread&gt;(new thread(&amp;bar));
   for (int i= 0; i&lt;NUM_THREADS;
      ++i)threads[i]-&gt;join();
 }
 void foo()
 {
   thread_ref threads[NUM_THREADS];
   for (int i=0; i&lt;NUM_THREADS; ++i)
      threads[i] = create_thread(&amp;bar);
   for (int i= 0; i&lt;NUM_THREADS;
      ++i)threads[i]-&gt;join();    
 }
 </pre>
 <h3>5.</h3>
 <pre>
 void foo()
 {
   thread thrd* = new thread(&amp;bar);
   manager.owns(thread);
 }
 void foo()
 {
   thread_ref thrd = create_thread(&amp;bar);
   manager.owns(thrd);
 }
 </pre>
 <h3>6.</h3>
 <pre>
 void foo()
 {
   boost::shared_ptr&lt;thread&gt; thrd(new thread(&amp;bar));
   manager1.add(thrd);
   manager2.add(thrd);
 }
 void foo()
 {
   thread_ref thrd = create_thread(&amp;bar);
   manager1.add(thrd);
   manager2.add(thrd);
 }
 </pre>
 <p>This shows the usage patterns being nearly identical in complexity for both 
  designs. The only actual added complexity occurs because of the use of operator 
  new in (4), (5) and (6) and the use of std::auto_ptr and boost::shared_ptr in 
  (4) and (6) respectively. However, that&#39;s not really much added complexity, 
  and C++ programmers are used to using these idioms any way. Some may dislike 
  the presence of operator new in user code, but this can be eliminated by proper 
  design of higher level concepts, such as the boost::thread_group class that 
  simplifies example (4) down to:</p>
 <pre>
 void foo()
 {
   thread_group threads;
   for (int i=0; i&lt;NUM_THREADS; ++i)
      threads.create_thread(&amp;bar);
   threads.join_all();
 }
 </pre>
 <p>So ease of use is really a wash and not much help in picking a design.</p>
 <p>So what about performance? If you look at the above code examples we can analyze 
  the theoretical impact to performance that both designs have. For (1) we can 
  see that platforms that don&#39;t have a ref-counted native thread type (POSIX, 
  for instance) will be impacted by a thread_ref design. Even if the native thread 
  type is ref-counted there may be an impact if more state information has to 
  be maintained for concepts foreign to the native API, such as clean up stacks 
  for Win32 implementations. For (2) the performance impact will be identical 
  to (1). The same for (3). For (4) things get a little more interesting and we 
  find that theoretically at least the thread_ref may perform faster since the 
  thread design requires dynamic memory allocation/deallocation. However, in practice 
  there may be dynamic allocation for the thread_ref design as well, it will just 
  be hidden from the user. As long as the implementation has to do dynamic allocations 
  the thread_ref loses again because of the reference management. For (5) we see 
  the same impact as we do for (4). For (6) we still have a possible impact to 
  the thread design because of dynamic allocation but thread_ref no longer suffers 
  because of its reference management, and in fact, theoretically at least, the 
  thread_ref may do a better job of managing the references. All of this indicates 
  that thread wins for (1), (2) and (3), with (4) and (5) the winner depends on 
  the implementation and the platform but the thread design probably has a better 
  chance, and with (6) it will again depend on the implementation and platform 
  but this time we favor thread_ref slightly. Given all of this it&#39;s a narrow 
  margin, but the thread design prevails.</p>
 <p>Given this analysis, and the fact that noncopyable objects for system resources 
  are the normal designs that C++ programmers are used to dealing with, the <b>Boost.Threads</b> 
  library has gone with a noncopyable design.</p>
 <h2><a name="events"></a>Rationale for not providing <i>Event Variables</i></h2>
 <p><i>Event variables</i> are simply far too error-prone. <a href=
        "condition.html">Condition variables</a> are a much safer alternative.</p>
 <p>[Note that Graphical User Interface <i>events</i> are a different concept, 
  and are not what is being discussed here.]</p>
 <p>Event variables were one of the first synchronization primitives. They are 
  still used today, for example, in the native Windows multithreading API.</p>
 <p>Yet both respected computer science researchers and experienced multithreading 
  practitioners believe event variables are so inherently error-prone that they 
  should never be used, and thus should not be part of a multithreading library.</p>
 <p>Per Brinch Hansen <a href="bibliography.html#Brinch-Hansen-73"> [Brinch Hansen 
  73]</a> analyzed event variables in some detail, pointing out [emphasis his] 
  that &quot;<i>event operations force the programmer to be aware of the relative 
  speeds of the sending and receiving processes</i>&quot;. His summary:</p>
 <blockquote> 
  <p>We must therefore conclude that event variables of the previous type are 
    impractical for system design. <i>The effect of an interaction between two 
    processes must be independent of the speed at which it is carried out.</i></p>
 </blockquote>
 <p>Experienced programmers using the Windows platform today report that event 
  variables are a continuing source of errors, even after previous bad experiences 
  caused them to be very careful in their use of event variables. Overt problems 
  can be avoided, for example, by teaming the event variable with a mutex, but 
  that may just convert a <a href=
        "definitions.html#Race condition">race condition</a> into another problem, 
  such as excessive resource use. One of the most distressing aspects of the experience 
  reports is the claim that many defects are latent. That is, the programs appear 
  to work correctly, but contain hidden timing dependencies which will cause them 
  to fail when environmental factors or usage patterns change, altering relative 
  thread timings.</p>
 <p>The decision to exclude event variables from <b>Boost.Threads</b> has been 
  surprising to some Windows programmers. They have written programs which work 
  using event variables, and wonder what the problem is. It seems similar to the 
  &quot;goto considered harmful&quot; controversy of 30 years ago. It isn&#39;t 
  that events, like gotos, can&#39;t be made to work, but rather that virtually 
  all programs using alternatives will be easier to write, debug, read, maintain, 
  and be less likely to contain latent defects.</p>
 <p>[Rationale provided by Beman Dawes]</p>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/recursive_mutex.html
+++ b/doc/recursive_mutex.html
@@ -0,0 +1,288 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Header &lt;boost/thread/recursive_mutex.hpp&gt;</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Header &lt;<a href="../../../boost/thread/recursive_mutex.hpp">boost/thread/recursive_mutex.hpp</a>&gt;</h2>    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#classes">Classes</a></dt>
  <dl class="page-index"> 
    <dt><a href="#class-recursive_mutex">Class <code>recursive_mutex</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-recursive_mutex-synopsis">Class <code>recursive_mutex</code> 
        synopsis</a></dt>
      <dt><a href="#class-recursive_mutex-ctors">Class <code>recursive_mutex</code> 
        constructors and destructor</a></dt>
    </dl>
    <dt><a href="#class-recursive_try_mutex">Class <code>recursive_try_mutex</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-recursive_try_mutex-synopsis">Class <code>recursive_try_mutex</code> 
        synopsis</a></dt>
      <dt><a href="#class-recursive_try_mutex-ctors">Class <code>recursive_try_mutex</code> 
        constructors and destructor</a></dt>
    </dl>
    <dt><a href="#class-recursive_timed_mutex">Class <code>recursive_timed_mutex</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-recursive_timed_mutex-synopsis">Class <code>recursive_timed_mutex</code> 
        synopsis</a></dt>
      <dt><a href="#class-recursive_timed_mutex-ctors">Class <code>recursive_timed_mutex</code> 
        constructors and destructor</a></dt>
    </dl>
  </dl>
  <dt><a href="#examples">Example(s)</a></dt>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>Include the header &lt;<a href="../../../boost/thread/recursive_mutex.hpp">boost/thread/recursive_mutex.hpp</a>&gt; 
  to define the <a href="#class-recursive_mutex">recursive_mutex</a>, <a href="#class-recursive_try_mutex">recursive_try_mutex</a> 
  and <a href="#class-recursive_timed_mutex">recursive_timed_mutex</a> classes.</p>
 <p>The <a href="#class-recursive_mutex">recursive_mutex</a>, <a href="#class-recursive_try_mutex">recursive_try_mutex</a> 
  and <a href="#class-recursive_timed_mutex">recursive_timed_mutex</a> classes 
  are models of <a href="mutex_concept.html#Mutex-concept">Mutex</a>, <a href="mutex_concept.html#TryMutex-concept">TryMutex</a>, 
  and <a href="mutex_concept.html#TimedMutex-concept">TimedMutex</a> respectively. 
  These types should be used to synchronize access to shared resources when recursive 
  locking by a single thread is likely to occur. A good example for this is when 
  a class supplies &quot;internal synchronization&quot; to ensure <a href="definitions.html#Thread-safe"> 
  thread-safety</a> and a function of the class may have to call other functions 
  of the class which also attempt to lock the mutex. For recursive locking mechanics, 
  see <a href="mutex.html">mutexes</a>.</p>
 <p>Each class supplies one or more typedefs for lock types which model matching 
  lock concepts. For the best possible performance you should use the mutex class 
  that supports the minimum set of lock types that you need.</p>
 <table summary="lock types" border="1" cellpadding="5">
  <tr> 
    <td><b>Mutex Class</b></td>
    <td><b>Lock name</b></td>
    <td><b>Lock Concept</b></td>
  </tr>
  <tr> 
    <td valign="top"><a href="#recursive_mutex Synopsis"><code> recursive_mutex</code></a></td>
    <td valign="middle"><code>scoped_lock</code></td>
    <td valign="middle"><a href="lock_concept.html#ScopedLock"> ScopedLock</a></td>
  </tr>
  <tr> 
    <td valign="top"><code><a href="#recursive_try_mutex Synopsis"> recursive_try_mutex</a></code></td>
    <td valign="middle"><code>scoped_lock<br>
      scoped_try_lock</code></td>
    <td valign="middle"><a href="lock_concept.html#ScopedLock"> ScopedLock</a><br>
      <a href="lock_concept.html#ScopedTryLock"> ScopedTryLock</a></td>
  </tr>
  <tr> 
    <td valign="top"><code><a href=
                "#recursive_timed_mutex Synopsis"> recursive_timed_mutex</a></code> 
    </td>
    <td valign="middle"><code>scoped_lock<br>
      scoped_try_lock<br>
      scoped_timed_lock</code></td>
    <td valign="middle"><a href="lock_concept.html#ScopedLock"> ScopedLock</a><br>
      <a href="lock_concept.html#ScopedTryLock"> ScopedTryLock</a><br>
      <a href="lock_concept.html#ScopedTimedLock"> ScopedTimedLock</a></td>
  </tr>
 </table>
 <p>The <code>recursive_mutex</code>, <code>recursive_try_mutex</code> and <code>recursive_timed_mutex</code> 
  employ a <code>Recursive</code> <a href="mutex_concept.html#LockingStrategies">locking 
  strategy</a>, so attempts to recursively lock them succeed and an internal &quot;lock 
  count&quot; is maintained. Attempts to unlock them by a thread that does not 
  own a lock on them will result in <b>undefined behavior</b>.</p>
 <p>The <code>recursive_mutex</code>, <code>recursive_try_mutex</code> and <code>recursive_timed_mutex</code> 
  leave the <a href=
        "mutex_concept.html#SchedulingPolicies">scheduling policy</a> as <code> 
  Unspecified</code>. Programmers should assume that threads waiting for a lock 
  on objects of these types acquire the lock in a random order, even though the 
  specific behavior for a given platform may be different.</p>
 <h2><a name="classes"></a>Classes</h2>
 <h3><a name="class-recursive_mutex"></a>Class <code>recursive_mutex</code></h3>
 <p>The <code>recursive_mutex</code> class is a model of <a href="mutex_concept.html#Mutex-concept">Mutex</a> 
  and <a href="overview.html#non-copyable">NonCopyable</a>, and provides no additional 
  facilities beyond the requirements of these concepts.</p>
 <h4><a name="class-recursive_mutex-synopsis"></a>Class <code>recursive_mutex</code> 
  synopsis</h4>
 <pre>
 namespace boost
 {
    class recursive_mutex : private boost::noncopyable // Exposition only.
        // Class recursive_mutex meets the NonCopyable requirement.
    {
    public:
        typedef [implementation defined; see Introduction] scoped_lock;
        recursive_mutex();
        ~recursive_mutex();
    };
 };
 </pre>
 <h4><a name="class-recursive_mutex-ctors"></a>Class <code>recursive_mutex</code> 
  constructors and destructor</h4>
 <pre>
 recursive_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Postconditions:</b> <code>*this</code> is in an unlocked state.</dt>
 </dl>
 <pre>
 ~recursive_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>*this</code> is in an unlocked sate.</dt>
  <dt><b>Danger:</b> Destruction of a locked mutex is a serious programming error 
    resulting in undefined behavior such as a program crash.</dt>
 </dl>
 <h3><a name="class-recursive_try_mutex"></a>Class <code>recursive_try_mutex</code></h3>
 <p>The <code>recursive_try_mutex</code> class is a model of <a href="mutex_concept.html#TryMutex-concept">TryMutex</a> 
  and <a href="overview.html#non-copyable">NonCopyable</a>, and provides no additional 
  facilities beyond the requirements of these concepts.</p>
 <h4><a name="class-recursive_try_mutex-synopsis"></a>Class <code>recursive_try_mutex</code> 
  synopsis</h4>
 <pre>
 namespace boost
 {
    class recursive_mutex : private boost::noncopyable // Exposition only.
        // Class recursive_mutex meets the NonCopyable requirement.
    {
    Public:
        typedef [implementation defined; see Introduction] scoped_lock;
        typedef [implementation defined; see Introduction] scoped_try_lock;
        recursive_try_mutex();
        ~recursive_try_mutex();
    };
 };
 </pre>
 <h4><a name="class-recursive_try_mutex-ctors"></a>Class <code>recursive_try_mutex</code> 
  constructors and destructor</h4>
 <pre>
 recursive_try_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Postconditions:</b> <code>*this</code> is in an unlocked state.</dt>
 </dl>
 <pre>
 ~recursive_try_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>*this</code> is in an unlocked sate.</dt>
  <dt><b>Danger:</b> Destruction of a locked mutex is a serious programming error 
    resulting in undefined behavior such as a program crash.</dt>
 </dl>
 <h3><a name="class-recursive_timed_mutex"></a>Class <code>recursive_timed_mutex</code></h3>
 <p>The <code>recursive_timed_mutex</code> class is a model of <a href="mutex_concept.html#TimedMutex-concept">TimedMutex</a> 
  and <a href="overview.html#non-copyable">NonCopyable</a>, and provides no additional 
  facilities beyond the requirements of these concepts.</p>
 <h4><a name="class-recursive_timed_mutex-synopsis"></a>Class <code>recursive_timed_mutex</code> 
  synopsis</h4>
 <pre>
 namespace boost
 {
    class recursive_timed_mutex : private boost::noncopyable // Exposition only.
        // Class recursive_mutex meets the NonCopyable requirement.
    {
    Public:
        typedef [implementation defined; see Introduction] scoped_lock;
        typedef [implementation defined; see Introduction] scoped_try_lock;
        typedef [implementation defined; see Introduction] scoped_timed_lock;
        recursive_timed_mutex();
        ~recursive_timed_mutex();
    };
 };
 </pre>
 <h4><a name="class-recursive_timed_mutex-ctors"></a>Class <code>recursive_timed_mutex</code> 
  constructors and destructor</h4>
 <pre>
 recursive_timed_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Postconditions:</b> <code>*this</code> is in an unlocked state.</dt>
 </dl>
 <pre>
 ~recursive_timed_mutex();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>*this</code> is in an unlocked sate.</dt>
  <dt><b>Danger:</b> Destruction of a locked mutex is a serious programming error 
    resulting in undefined behavior such as a program crash.</dt>
 </dl>
 <h2><a name="examples"></a>Example(s)</h2>
 <pre>
 #include <a href="../../../boost/thread/recursive_mutex.hpp">&lt;boost/thread/recursive_mutex.hpp&gt;</a>
 #include <a href="../../../boost/thread/thread.hpp">&lt;boost/thread/thread.hpp&gt;</a>
 #include &lt;iostream&gt;
 class counter
 {
 public:
    counter() : count(0) { }
    int add(int val) {
        boost::recursive_mutex::scoped_lock scoped_lock(mutex);
        count += val;
        return count;
    }   
    int increment() {
        boost::recursive_mutex::scoped_lock scoped_lock(mutex);
        return add(1);
    }
 private:
    boost::recursive_mutex mutex;
    int count;
 };
 counter c;
 void change_count(void*)
 {
    std::cout &lt;&lt; &quot;count == &quot; &lt;&lt; c.increment() &lt;&lt; std::endl;
 }
 int main(int, char*[])
 {
    const int num_threads=4;
    boost::thread_group threads;   
    for (int i=0; i &lt; num_threads; ++i)
        threads.create_thread(&amp;change_count, 0);
    threads.join_all();
    return 0;
 }
 </pre>
 <p>The output is:</p>
 <pre>
 count == 1
 count == 2
 count == 3
 count == 4
 </pre>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/thread.html
+++ b/doc/thread.html
@@ -0,0 +1,372 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - &lt;boost/thread.hpp&gt;</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Header &lt;<a href="../../../boost/thread/thread.hpp">boost/thread.hpp</a>&gt;</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#classes">Classes</a></dt>
  <dl class="page-index"> 
    <dt><a href="#class-thread">Class <code>thread</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-thread-synopsis">Class <code>thread</code> synopsis</a></dt>
      <dt><a href="#class-thread-ctors">Class <code>thread</code> constructors 
        and destructor</a></dt>
      <dt><a href="#class-thread-comparisons">Class <code>thread</code> comparison 
        functions</a></dt>
      <dt><a href="#class-thread-modifiers">Class <code>thread</code> modifier 
        functions</a></dt>
      <dt><a href="#class-thread-statics">Class <code>thread</code> static functions</a></dt>
    </dl>
    <dt><a href="#class-thread_group">Class <code>thread_group</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-thread_group-synopsis">Class <code>thread_group</code> 
        synopsis</a></dt>
      <dt><a href="#class-thread_group-ctors">Class <code>thread_group</code> 
        constructors and destructor</a></dt>
      <dt><a href="#class-thread_group-modifiers">Class <code>thread_group</code> 
        modifier functions</a></dt>
    </dl>
  </dl>
  <dt><a href="#examples">Example(s)</a></dt>
  <dl class="page-index"> 
    <dt><a href="#example-thread">Simple usage of <code>boost::thread</code></a></dt>
    <dt><a href="#example-thread_group">Simple usage of <code>boost::thread_group</code></a></dt>
  </dl>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>The header &lt;<a href="../../../boost/thread/thread.hpp">boost/thread.hpp</a>&gt; 
  defines the classes <a href="#class-thread">thread</a> and <a href="#class-thread_group">thread_group</a> 
  which are used to create, observe and manage threads and groups of threads.</p>
 <h2><a name="classes"></a>Classes</h2>
 <h3><a name="class-thread"></a>Class <code>thread</code></h3>
 <p>The <code>thread</code> class represents threads of execution, and provides 
  the functionality to create and manage threads within the <b> Boost.Threads</b> 
  library. See <a href="definitions.html"> Definitions</a> for a precise description 
  of &quot;thread of execution&quot;, and for definitions of threading related 
  terms and of thread states such as &quot;blocked&quot;.</p>
 <p>A thread of execution has an initial function. For the program&#39;s initial 
  thread, the initial function is <code>main()</code>. For other threads, the 
  initial function is <code>operator()</code> of the function object passed to 
  the class <code>thread</code> constructor.</p>
 <p>A thread of execution is said to be &quot;finished&quot; or &quot;finished 
  execution&quot; when its initial function returns or is terminated. This includes 
  completion of all thread cleanup handlers, and completion of the normal C++ 
  function return behaviors, such as destruction of automatic storage (stack) 
  objects and releasing any associated implementation resources.</p>
 <p>A thread object has an associated state which is either &quot;joinable&quot; 
  or &quot;non-joinable&quot;.</p>
 <p>Except as described below, the policy used by an implementation of <b>Boost.Threads</b> 
  to schedule transitions between thread states is unspecified.</p>
 <p><b>Note:</b> Just as the lifetime of a file may be different from the lifetime 
  of an iostream object which represents the file, the lifetime of a thread of 
  execution may be different from the <code> thread</code> object which represents 
  the thread of execution. In particular, after a call to <code>join()</code>, 
  the thread of execution will no longer exist even though the <code>thread</code> 
  object continues to exist until the end of its normal lifetime. The converse 
  is also possible; if a <code>thread</code> object is destroyed without <code>join()</code> 
  having first been called, the thread of execution continues until its initial 
  function completes.</p>
 <h4><a name="class-thread-synopsis"></a>Class <code>thread</code> synopsis</h4>
 <pre>
 namespace boost {
 class thread : <a href=
 "../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
   // Class thread meets the <a href=
 "overview.html#non-copyable">NonCopyable</a> requirement.
 {
 public:
    thread();
    explicit thread(const boost::function0&lt;void&gt;&amp; threadfunc);
    ~thread();
    bool operator==(const thread&amp; rhs) const;
    bool operator!=(const thread&amp; rhs) const;
    void join();
    static void sleep(const xtime&amp; xt);
    static void yield();
 };
 } // namespace boost
 </pre>
 <h4><a name="class-thread-ctors"></a>Class <code>thread</code> constructors and 
  destructor</h4>
 <pre>
 thread();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Constructs a <code>thread</code> object representing the 
    current thread of execution.</dt>
  <dt><b>Postconditions:</b> <code>*this</code> is non-joinable.</dt>
  <dt><b>Danger:</b> <code>*this</code> is valid only within the current thread.</dt>
 </dl>
 <pre>
 thread(const <a href="../../function/index.html">boost::function0</a>&lt;void&gt;&amp; threadfunc);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Starts a new thread of execution and constructs a <code>thread</code> 
    object representing it. Copies <code> threadfunc</code> (which in turn copies 
    the function object wrapped by <code>threadfunc</code>) to an internal location 
    which persists for the lifetime of the new thread of execution. Calls <code>operator()</code> 
    on the copy of the <code>threadfunc</code> function object in the new thread 
    of execution.</dt>
  <dt><b>Postconditions:</b> <code>*this</code> is joinable.</dt>
  <dt><b>Throws:</b> <code>boost::thread_resource_error</code> if a new thread 
    of execution cannot be started.</dt>
 </dl>
 <pre>
 ~Thread();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Destroys <code>*this</code>. The actual thread of execution 
    may continue to execute after the <code>thread</code> object has been destroyed.</dt>
  <dt><b>Note:</b> If <code>*this</code> is joinable the actual thread of execution 
    becomes &quot;detached&quot;. Any resources used by the thread will be reclaimed 
    when the thread of execution completes. To ensure such a thread of execution 
    runs to completion before the <code> thread</code> object is destroyed, call 
    <code>join()</code>.</dt>
 </dl>
 <h4><a name="class-thread-comparisons"></a>Class <code>thread</code> comparison 
  functions</h4>
 <pre>
 bool operator==(const thread&amp; rhs) const;
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> The thread is non-terminated or <code>*this</code> is joinable.</dt>
  <dt><b>Returns:</b> <code>true</code> if <code>*this</code> and <code> rhs</code> 
    represent the same thread of execution.</dt>
 </dl>
 <pre>
 bool operator!=(const thread&amp; rhs) const;
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> The thread is non-terminated or <code>*this</code> is joinable.</dt>
  <dt><b>Returns:</b> <code>!(*this==rhs)</code>.</dt>
 </dl>
 <h4><a name="class-thread-modifiers"></a>Class <code>thread</code> modifier functions</h4>
 <pre>
 void join();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>*this</code> is joinable.</dt>
  <dt><b>Effects:</b> The current thread of execution blocks until the initial 
    function of the thread of execution represented by <code> *this</code> finishes 
    and all resources are reclaimed.</dt>
  <dt><b>Postconditions:</b> <code>*this</code> is non-joinable.</dt>
  <dt><b>Notes:</b> If <code>*this == thread()</code> the result is implementation 
    defined. If the implementation doesn&#39;t detect this the result will be 
    <a href="definitions.html#Deadlock"> deadlock</a>.</dt>
 </dl>
 <h4><a name="class-thread-statics"></a>Class <code>thread</code> static functions</h4>
 <pre>
 static void sleep(const <a href="xtime.html">xtime</a>&amp; XT);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> The current thread of execution blocks until <code> XT</code> 
    is reached.</dt>
 </dl>
 <pre>
 static void yield();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> The current thread of execution is placed in the &quot;ready&quot; 
    state.</dt>
  <dt><b>Notes:</b> Allow the current thread to give up the rest of its time slice 
    (or other scheduling quota) to another thread. Particularly useful in non-preemptive 
    implementations.</dt>
 </dl>
 <h3><a name="class-thread_group"></a>Class <code>thread_group</code></h3>
 <p>The <tt>thread_group</tt> class provides a container for easy grouping of threads 
  to simplify several common thread creation and management idioms.</p>
 <p>All <tt>thread_group</tt> member functions are <a href=
        "definitions.html#thread-safe">thread-safe</a>, except destruction.</p>
 <h4><a name="class-thread_group-synopsis"></a>Class <code>thread_group</code> 
  synopsis</h4>
 <pre>
 namespace boost {
    class thread_group : <a href=
 "../../utility/utility.htm#Class noncopyable">boost::noncopyable</a>
    {
    public:
        thread_group();
        ~thread_group();
        thread* create_thread(const boost::function0&lt;void&gt;&amp; threadfunc);
        void add_thread(thread* thrd);
        void remove_thread(thread* thrd);
        void join_all();
    };
 } // namespace boost
 </pre>
 <h4><a name="class-thread_group-ctors"></a>Class <code>thread_group</code> constructors 
  and destructor</h4>
 <pre>
 thread_group();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Constructs an empty <code>thread_group</code> container.</dt>
 </dl>
 <pre>
 ~thread_group();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Destroys each contained thread object. Destroys <code>*this</code>.</dt>
  <dt><b>Notes:</b> Behavior is undefined if another thread references *this during 
    the execution of the destructor.</dt>
 </dl>
 <h4><a name="class-thread_group-modifiers"></a>Class <code>thread_group</code> 
  modifier functions</h4>
 <pre>
 thread* create_thread(const boost::function0&lt;void&gt;&amp; threadfunc);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Creates a new <tt>thread</tt> object that executes <tt>threadfunc</tt> 
    and adds it to the <tt>thread_group</tt> container object&#39;s list of managed 
    <tt>thread</tt> objects.</dt>
  <dt><b>Returns:</b> Pointer to the newly created thread.</dt>
 </dl>
 <pre>
 void add_thread(thread* thrd);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Adds <tt>thrd</tt> to the <tt>thread_group</tt> object&#39;s 
    list of managed <tt>thread</tt> objects. The <tt>thrd</tt> object must have 
    been allocated via operator new and will be deleted when the group is destroyed.</dt>
 </dl>
 <pre>
 Void remove_thread(thread* thrd);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Removes <code>*this</code>&#39;s list of managed <tt>thread</tt> 
    objects.</dt>
  <dt><b>Throws:</b> ? if <tt>thrd</tt> is not it <code>*this</code>&#39;s list 
    of managed <tt>thread</tt> objects.</dt>
 </dl>
 <pre>
 Void join_all();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> Calls <code>join()</code> on each of the managed <tt>thread</tt> 
    objects.</dt>
 </dl>
 <h2><a name="functions"></a>Functions</h2>
 <pre>
 <a name="function-spec"></a>{{function}}
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> {{text}}</dt>
  <dt><b>Effects:</b> {{text}}</dt>
  <dt><b>Postconditions:</b> {{text}}</dt>
  <dt><b>Returns:</b> {{text}}</dt>
  <dt><b>Throws:</b> {{text}}</dt>
  <dt><b>Complexity:</b> {{text}}</dt>
  <dt><b>Rationale:</b> {{text}}</dt>
 </dl>
 <h2><a name="objects"></a>Objects</h2>
 <p><a name="object-spec"></a>{{Object specifications}}</p>
 <h2><a name="examples"></a>Example(s)</h2>
 <h3><a name="example-thread"></a>Simple usage of <code>boost::thread</code></h3>
 <pre>
 #include &lt;boost/thread/thread.hpp&gt;
 #include &lt;iostream&gt;
 struct thread_alarm
 {
   thread_alarm(int secs) : m_secs(secs) { }
   void operator()()
   {
       boost::xtime XT;
       boost::xtime_get(&amp;XT, boost::TIME_UTC);
       xt.sec += m_secs;
       boost::thread::sleep(XT);
       std::cout &lt;&lt; &quot;alarm sounded...&quot; &lt;&lt; std::endl;
   }
   int m_secs;
 };
 int main(int argc, char* argv[])
 {
   int secs = 5;
   std::cout &lt;&lt; &quot;setting alarm for 5 seconds...&quot; &lt;&lt; std::endl;
   thread_alarm alarm(secs);
   boost::thread thrd(alarm);
   thrd.join();
 }
 </pre>
 <p>The output is:</p>
 <pre>
 setting alarm for 5 seconds...
 alarm sounded...
 </pre>
 <h3><a name="example-thread_group"></a>Simple usage of <code>boost::thread_group</code></h3>
 <pre>
 #include &lt;boost/thread/thread.hpp&gt;
 #include &lt;iostream&gt;
 int count = 0;
 boost::mutex mutex;
 void increment_count()
 {
   boost::mutex::lock lock(mutex);
   std::cout &lt;&lt; &quot;count = &quot; &lt;&lt; ++count &lt;&lt; std::endl;
 }
 int main(int argc, char* argv[])
 {
   boost::thread_group threads;
   for (int i = 0; i &lt; 10; ++i)
      threads.create_thread(&amp;increment_count);
   threads.join_all();
 }
 </pre>
 <p>The output is:</p>
 <pre>
 count = 1
 count = 2
 count = 3
 count = 4
 count = 5
 count = 6
 count = 7
 count = 8
 count = 9
 count = 10
 </pre>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/tss.html
+++ b/doc/tss.html
@@ -0,0 +1,200 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Header &lt;boost/thread/tss.hpp&gt;</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Header &lt;<a href="../../../boost/thread/tss.hpp">boost/thread/tss.hpp</a>&gt;</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#classes">Classes</a></dt>
  <dl class="page-index"> 
    <dt><a href="#class-thread_specific_ptr">Class <code>thread_specific_ptr</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-thread_specific_ptr-synopsis">Class <code>thread_specific_ptr</code> 
        synopsis</a></dt>
      <dt><a href="#class-thread_specific_ptr-ctors">Class <code>thread_specific_ptr</code> 
        constructors and destructor</a></dt>
      <dt><a href="#class-thread_specific_ptr-modifiers">Class <code>thread_specific_ptr</code> 
        modifier functions</a></dt>
      <dt><a href="#class-thread_specific_ptr-observers">Class <code>thread_specific_ptr</code> 
        observer functions</a></dt>
    </dl>
  </dl>
  <dt><a href="#examples">Example(s)</a></dt>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>The header &lt;<a href="../../../boost/thread/tss.hpp">boost/thread/tss.hpp</a>&gt; 
  defines the class <a href="#class-thread_specific_ptr">thread_specific_ptr</a> 
  which is used to manage data associated with specific thread instances.</p>
 <h2><a name="classes"></a>Classes</h2>
 <h3><a name="class-thread_specific_ptr"></a>Class <code>thread_specific_ptr</code></h3>
 <p>The <code>thread_specific_ptr</code> class defines an interface for using thread 
  specific storage. Thread specific storage is data associated with individual 
  threads and is often used to make operations <a href="definitions.html#Thread-safe">thread-safe</a> 
  that rely on global data.</p>
 <p>Template <code>thread_specific_ptr</code> stores a pointer to an object obtained 
  via <code>new</code> on a thread-by-thread basis and calls delete on the contained 
  pointer when the thread terminates. Each thread initially stores the null pointer 
  in each <code> thread_specific_ptr</code> instance.</p>
 <p>The template <code>thread_specific_ptr</code> is useful in the following cases:</p>
 <ul>
  <li>An interface was originally written assuming a single thread of control 
    and is being ported to a multithreaded environment.</li>
  <li>Each thread of control invokes sequences of methods that share data that 
    must be logically accessed through a globally visible access point, but are 
    physically unique for each thread, instead of being explicitly passed.</li>
 </ul>
 <h4><a name="class-thread_specific_ptr-synopsis"></a>Class <code>thread_specific_ptr</code> 
  synopsis</h4>
 <pre>
 namespace boost
 {
    template &lt;typename T&gt;
    class thread_specific_ptr : private boost::noncopyable // Exposition only.
        // Class thread_specific_ptr meets the <a href="overview.html#non-copyable">NonCopyable</a> requirement.
    {
    public:
        thread_specific_ptr();
        ~thread_specific_ptr();
        T* get() const;
        T* operator-&gt;() const;
        T&amp; operator*() const;
        T* release();
        void reset(T* p=0);
    };
 };
 </pre>
 <h4><a name="class-thread_specific_ptr-ctors"></a>Class <code>thread_specific_ptr</code> 
  constructors and destructor</h4>
 <pre>
 thread_specific_ptr();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> The expression <code>delete get()</code> is well formed.</dt>
  <dt><b>Postconditions:</b> A thread specific storage has been reserved for use 
    by <code>*this</code> in all threads, with each thread initially storing a 
    null pointer.</dt>
  <dt><b>Throws:</b> <code>boost::thread_resource_error</code> if the necessary 
    resources can not be obtained.</dt>
  <dt><b>Note:</b> There is an implementation specific limit to the number of 
    thread specific storage objects that can be created, and this limit may be 
    small.</dt>
 </dl>
 <pre>
 ~thread_specific_ptr();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Note:</b> Does not destroy any data that may be stored in any thread&#39;s 
    thread specific storage. For this reason you should not destroy a <code>thread_specific_ptr</code> 
    object until you are certain there are no threads running that have made use 
    of its thread specific storage.</dt>
 </dl>
 <h4><a name="class-thread_specific_ptr-modifiers"></a>Class <code>thread_specific_ptr</code> 
  modifier functions</h4>
 <pre>
 T* release();
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Postconditions:</b> <code>*this</code> holds the null pointer for the 
    current thread.</dt>
  <dt><b>Returns:</b> <code>this-&gt;get()</code> prior to the call.</dt>
 </dl>
 <pre>
 void reset(T* p=0);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Effects:</b> If <code>this-&gt;get()!= p</code> then <code>delete this-&gt;get()</code>. 
  </dt>
  <dt><b>Postconditions:</b> <code>*this</code> holds the pointer <code> p</code> 
    for the current thread.</dt>
  <dt><b>Note:</b> The pointer will be deleted when the thread terminates.</dt>
 </dl>
 <h4><a name="class-thread_specific_ptr-observers"></a>Class <code>thread_specific_ptr</code> 
  observer functions</h4>
 <pre>
 T* get() const;
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Returns:</b> The object stored in thread specific storage for the current 
    thread for <code>*this</code>.</dt>
  <dt><b>Note:</b> Each thread initially returns 0.</dt>
 </dl>
 <pre>
 T* operator-&gt;() const;
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Returns:</b> <code>this-&lt;get()</code>.</dt>
 </dl>
 <pre>
 T& operator*() const;
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Requires:</b> <code>this-&lt;get() != 0</code></dt>
  <dt><b>Returns:</b> <code>this-&lt;get()</code>.</dt>
 </dl>
 <h2><a name="examples"></a>Example(s)</h2>
 <pre>
 #include <a href="../../../boost/thread/thread.hpp">&lt;boost/thread/thread.hpp&gt;</a>
 #include <a href="../../../boost/thread/tss.hpp">&lt;boost/thread/tss.hpp&gt;</a>
 #include &lt;cassert&gt;
 boost::thread_specific_ptr&lt;int&gt; value;
 void increment()
 {
   int* p = value.get();
   ++*p;
 }
 void thread_proc()
 {
   value.reset(new int(0)); // initialize the thread&#39;s storage
   for (int i=0; i&lt;10; ++i)
   {
       increment();
       int* p = value.get();
       assert(*p == i+1);
   }
 }
 int main(int argc, char* argv[])
 {
   boost::thread_group threads;
   for (int i=0; i&lt;5; ++i)
      threads.create_thread(&amp;thread_proc);
   threads.join_all();
 }
 </pre>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/doc/xtime.html
+++ b/doc/xtime.html
@@ -0,0 +1,121 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <link rel="stylesheet" type="text/css" href="../../../boost.css">
 <title>Boost.Threads - Header &lt;boost/thread/xtime.hpp&gt;</title>
 </head>
 <body link="#0000ff" vlink="#800080">
 <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
    "header">
  <tr> 
    <td valign="top" width="300"> 
      <h3><a href="../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../c++boost.gif" border="0"></a></h3>
    </td>
    <td valign="top"> 
      <h1 align="center">Boost.Threads</h1>
      <h2 align="center">Header &lt;<a href="../../../boost/thread/xtime.hpp">boost/thread/xtime.hpp</a>&gt;</h2>
    </td>
  </tr>
 </table>
 <hr>
 <h2>Contents</h2>
 <dl class="page-index"> 
  <dt><a href="#introduction">Introduction</a></dt>
  <dt><a href="#values">Values</a></dt>
  <dl class="page-index"> 
    <dt><a href="#value-spec">TIME_UTC</a></dt>
  </dl>
  <dt><a href="#classes">Classes</a></dt>
  <dl class="page-index"> 
    <dt><a href="#class-spec">Struct <code>xtime</code></a></dt>
    <dl class="page-index"> 
      <dt><a href="#class-xtime-synopsis">Struct <code>xtime</code> synopsis</a></dt>
    </dl>
  </dl>
  <dt><a href="#functions">Functions</a></dt>
  <dl class="page-index"> 
    <dt><a href="#function-xtime_get"><code>xtime_get</code></a></dt>
  </dl>
  <dt><a href="#examples">Example(s)</a></dt>
 </dl>
 <hr>
 <h2><a name="introduction"></a>Introduction</h2>
 <p>The header &lt;<a href="../../../boost/thread/xtime.hpp">boost/thread/xtime.hpp</a>&gt; 
  defines functions and data types used to perform high-resolution time operations. 
  This is a temporary solution that will be replaced by a more robust time library 
  once available in Boost.</p>
 <h2><a name="values"></a>Values</h2>
 <pre><a name="value-spec"></a>
 enum
 {
    TIME_UTC
 }
 </pre>
 <p>The clock type for Coordinated Universal Time (UTC). The epoch for this clock 
  type is 1970-01-01 00:00:00. This is the only clock type supported by <b>Boost.Threads</b>.</p>
 <h2><a name="classes"></a>Classes</h2>
 <h3><a name="class-xtime"></a>Struct <code>xtime</code></h3>
 <p>The <code>xtime</code> type is used to represent a point on some time scale 
  or a duration in time. This type may be proposed for the C standard by Markus 
  Kuhn. <b>Boost.Threads</b> provides only a very minimal implementation of this 
  proposal and it&#39;s expected that a full implementation (or some other time 
  library) will be provided in Boost as a separate library, at which time <b>Boost.Threads</b> 
  will deprecate its implementation.</p>
 <h4><a name="class-xtime-synopsis"></a>Struct <code>xtime</code> synopsis</h4>
 <pre>
 namespace boost
 {
    struct xtime
    {
 #if defined(BOOST_NO_INT64_T)
        int_fast32_t sec;
 #else
        int_fast64_t sec;
 #endif
        int_fast32_t nsec;
    };
 };
 </pre>
 <h2><a name="functions"></a>Functions</h2>
 <pre>
 <a name="function-xtime_get"></a>int xtime_get(struct xtime* xtp, int clock_type);
 </pre>
 <dl class="function-semantics"> 
  <dt><b>Postconditions:</b> <code>xtp</code> represents the current point in 
    time as a duration since the epoch specified by the <code> clock_type</code>.</dt>
  <dt><b>Returns:</b> <code>clock_type</code> if successful, otherwise 0.</dt>
  <dt><b>Note:</b> The resolution is implementation specific. For many implementations 
    the best resolution of time is far more than one nanosecond, and even when 
    the resolution is reasonably good, the latency of a call to <code>xtime_get()</code> 
    may be significant. For maximum portability, avoid durations of less than 
    one second.</dt>
 </dl>
 <h2><a name="examples"></a>Example(s)</h2>
 <pre>
 #include <a href="../../../boost/thread/thread.hpp">&lt;boost/thread/thread.hpp&gt;</a>
 #include <a href="../../../boost/thread/tss.hpp">&lt;boost/thread/xtime.hpp&gt;</a>
 int main(int argc, char* argv[])
 {
   boost::xtime xt;
   boost::xtime_get(&amp;XT, boost::TIME_UTC);
   xt.sec += 1;
   boost::thread::sleep(XT); // Sleep for 1 second
 }
 </pre>
 <hr>
 <p>Revised 
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
  05 November, 2001 
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 </p>
 <p><i>&copy; Copyright <a href="mailto:wekempf@cox.net">William E. Kempf</a> 2001-2002. 
  All Rights Reserved.</i></p>
 <p>Permission to use, copy, modify, distribute and sell this software and its 
  documentation for any purpose is hereby granted without fee, provided that the 
  above copyright notice appear in all copies and that both that copyright notice 
  and this permission notice appear in supporting documentation. William E. Kempf 
  makes no representations about the suitability of this software for any purpose. 
  It is provided &quot;as is&quot; without express or implied warranty.</p>
 </body>
 </html>
--- a/example/.cvsignore
+++ b/example/.cvsignore
@@ -0,0 +1,2 @@
 bin
 *.pdb
--- a/example/Jamfile
+++ b/example/Jamfile
@@ -0,0 +1,68 @@
 #  (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell and
 #  distribute this software is granted provided this copyright notice appears
 #  in all copies. This software is provided "as is" without express or implied
 #  warranty, and with no claim as to its suitability for any purpose.
 #
 # Boost.Threads build and test Jamfile
 #
 # Declares the following targets:
 #   1. monitor, an example program.
 #   2. starvephil, an example program.
 #   3. tennis, an example program.
 # 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"
 # Declare the location of this subproject relative to the root.
 subproject libs/thread/example ;
 # 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.
 SEARCH on <module@>threads.jam = $(BOOST_ROOT)/libs/thread/build ;
 include <module@>threads.jam ;
 #######################
 # Declare the Boost.Threads example program monitor.
 exe monitor
    : monitor/monitor.cpp
      <lib>../build/boost_thread
      $(threadmon)
    : <sysinclude>$(BOOST_ROOT)
      $(pthreads-win32)
      <threading>multi
    : debug release <runtime-link>static/dynamic
 ;
 #######################
 # Declare the Boost.Threads example program starvephil.
 exe starvephil
    : starvephil/starvephil.cpp
      <lib>../build/boost_thread
      $(threadmon)
    : <sysinclude>$(BOOST_ROOT)
      $(pthreads-win32)
      <threading>multi
    : debug release <runtime-link>static/dynamic
 ;
 #######################
 # Declare the Boost.Threads example program tennis.
 exe tennis
    : tennis/tennis.cpp
      <lib>../build/boost_thread
      $(threadmon)
    : <sysinclude>$(BOOST_ROOT)
      $(pthreads-win32)
      <threading>multi
    : debug release <runtime-link>static/dynamic
 ;
--- a/example/monitor/Carbon.r
+++ b/example/monitor/Carbon.r
@@ -0,0 +1 @@
 /*
--- a/example/monitor/monitor.cpp
+++ b/example/monitor/monitor.cpp
@@ -0,0 +1,106 @@
 #include <vector>
 #include <iostream>
 #include <boost/thread/condition.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 namespace {
    const int ITERS = 100;
    boost::mutex io_mutex;
 }
 template <typename M>
 class buffer_t
 {
 public:
    typedef typename M::scoped_lock scoped_lock;
    buffer_t(int n)
        : p(0), c(0), full(0), buf(n)
    {
    }
    void send(int m)
    {
        scoped_lock lk(mutex);
        while (full == buf.size())
            cond.wait(lk);
        buf[p] = m;
        p = (p+1) % buf.size();
        ++full;
        cond.notify_one();
    }
    int receive()
    {
        scoped_lock lk(mutex);
        while (full == 0)
            cond.wait(lk);
        int i = buf[c];
        c = (c+1) % buf.size();
        --full;
        cond.notify_one();
        return i;
    }
    static buffer_t& get_buffer()
    {
        static buffer_t buf(2);
        return buf;
    }
    static void do_sender_thread()
    {
        for (int n = 0; n < ITERS; ++n)
        {
            {
                boost::mutex::scoped_lock lock(io_mutex);
                std::cout << "sending: " << n << std::endl;
            }
            get_buffer().send(n);
        }
    }
    static void do_receiver_thread()
    {
        for (int x=0; x < (ITERS/2); ++x)
        {
            int n = get_buffer().receive();
            {
                boost::mutex::scoped_lock lock(io_mutex);
                std::cout << "received: " << n << std::endl;
            }
        }
    }
 private:
    M mutex;
    boost::condition cond;
    unsigned int p, c, full;
    std::vector<int> buf;
 };
 template <typename M>
 void do_test(M* dummy=0)
 {
    typedef buffer_t<M> buffer_type;
    buffer_type::get_buffer();
    boost::thread thrd1(&buffer_type::do_receiver_thread);
    boost::thread thrd2(&buffer_type::do_receiver_thread);
    boost::thread thrd3(&buffer_type::do_sender_thread);
    thrd1.join();
    thrd2.join();
    thrd3.join();
 }
 void test_buffer()
 {
    do_test<boost::mutex>();
    do_test<boost::recursive_mutex>();
 }
 int main()
 {
    test_buffer();
    return 0;
 }
--- a/example/monitor/monitor.mcp
+++ b/example/monitor/monitor.mcp
--- a/example/starvephil/Carbon.r
+++ b/example/starvephil/Carbon.r
@@ -0,0 +1 @@
 /*
--- a/example/starvephil/starvephil.cpp
+++ b/example/starvephil/starvephil.cpp
@@ -0,0 +1,171 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <iostream>
 #include <time.h>
 namespace
 {
    boost::mutex iomx;
 }
 class canteen
 {
 public:
    canteen() : m_chickens(0) { }
    void get(int id)
    {
        boost::mutex::scoped_lock lock(m_mutex);
        while (m_chickens == 0)
        {
            {
                boost::mutex::scoped_lock lock(iomx);
                std::cout << "(" << clock() << ") Phil" << id <<
                    ": wot, no chickens?  I'll WAIT ..." << std::endl;
            }
            m_condition.wait(lock);
        }
        {
            boost::mutex::scoped_lock lock(iomx);
            std::cout << "(" << clock() << ") Phil" << id <<
                ": those chickens look good ... one please ..." << std::endl;
        }
        m_chickens--;
    }
    void put(int value)
    {
        boost::mutex::scoped_lock lock(m_mutex);
        {
            boost::mutex::scoped_lock lock(iomx);
            std::cout << "(" << clock() <<
                ") Chef: ouch ... make room ... this dish is very hot ..." << std::endl;
        }
        boost::xtime xt;
        boost::xtime_get(&xt, boost::TIME_UTC);
        xt.sec += 3;
        boost::thread::sleep(xt);
        m_chickens += value;
        {
            boost::mutex::scoped_lock lock(iomx);
            std::cout << "(" << clock() <<
                ") Chef: more chickens ... " << m_chickens <<
                " now available ... NOTIFYING ..." << std::endl;
        }
        m_condition.notify_all();
    }
 private:
    boost::mutex m_mutex;
    boost::condition m_condition;
    int m_chickens;
 };
 canteen g_canteen;
 void chef()
 {
    const int chickens = 4;
    {
        boost::mutex::scoped_lock lock(iomx);
        std::cout << "(" << clock() << ") Chef: starting ..." << std::endl;
    }
    for (;;)
    {
        {
            boost::mutex::scoped_lock lock(iomx);
            std::cout << "(" << clock() << ") Chef: cooking ..." << std::endl;
        }
        boost::xtime xt;
        boost::xtime_get(&xt, boost::TIME_UTC);
        xt.sec += 2;
        boost::thread::sleep(xt);
        {
            boost::mutex::scoped_lock lock(iomx);
            std::cout << "(" << clock() << ") Chef: " << chickens
                << " chickens, ready-to-go ..." << std::endl;
        }
        g_canteen.put(chickens);
    }
 }
 struct phil
 {
    phil(int id) : m_id(id) { }
    void run() {
        {
            boost::mutex::scoped_lock lock(iomx);
            std::cout << "(" << clock() << ") Phil" << m_id << ": starting ..." << std::endl;
        }
        for (;;)
        {
            if (m_id > 0)
            {
                boost::xtime xt;
                boost::xtime_get(&xt, boost::TIME_UTC);
                xt.sec += 3;
                boost::thread::sleep(xt);
            }
            {
                boost::mutex::scoped_lock lock(iomx);
                std::cout << "(" << clock() << ") Phil" << m_id
                    << ": gotta eat ..." << std::endl;
            }
            g_canteen.get(m_id);
            {
                boost::mutex::scoped_lock lock(iomx);
                std::cout << "(" << clock() << ") Phil" << m_id
                    << ": mmm ... that's good ..." << std::endl;
            }
        }
    }
    static void do_thread(void* param) {
        static_cast<phil*>(param)->run();
    }
    int m_id;
 };
 struct thread_adapt
 {
    thread_adapt(void (*func)(void*), void* param) : _func(func), _param(param) { }
    int operator()() const
    {
        _func(_param);
        return 0;
    }
    void (*_func)(void*);
    void* _param;
 };
 class thread_adapter
 {
 public:
    thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
    void operator()() const { _func(_param); }
 private:
    void (*_func)(void*);
    void* _param;
 };
 int main(int argc, char* argv[])
 {
    boost::thread thrd_chef(&chef);
    phil p[] = { phil(0), phil(1), phil(2), phil(3), phil(4) };
    boost::thread thrd_phil0(thread_adapter(&phil::do_thread, &p[0]));
    boost::thread thrd_phil1(thread_adapter(&phil::do_thread, &p[1]));
    boost::thread thrd_phil2(thread_adapter(&phil::do_thread, &p[2]));
    boost::thread thrd_phil3(thread_adapter(&phil::do_thread, &p[3]));
    boost::thread thrd_phil4(thread_adapter(&phil::do_thread, &p[4]));
    thrd_chef.join();
    thrd_phil0.join();
    thrd_phil1.join();
    thrd_phil2.join();
    thrd_phil3.join();
    thrd_phil4.join();
    return 0;
 }
--- a/example/starvephil/starvephil.mcp
+++ b/example/starvephil/starvephil.mcp
--- a/example/tennis/Carbon.r
+++ b/example/tennis/Carbon.r
@@ -0,0 +1 @@
 /*
--- a/example/tennis/tennis.cpp
+++ b/example/tennis/tennis.cpp
@@ -0,0 +1,120 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <iostream>
 #if defined(BOOST_HAS_WINTHREADS)
 #   include <windows.h>
 #   include <process.h>
 #endif
 enum game_state
 {
    START,
    PLAYER_A,
    PLAYER_B,
    GAME_OVER,
    ONE_PLAYER_GONE,
    BOTH_PLAYERS_GONE
 };
 int state;
 boost::mutex mutex;
 boost::condition cond;
 char* player_name(int state)
 {
    if (state == PLAYER_A)
        return "PLAYER-A";
    if (state == PLAYER_B)
        return "PLAYER-B";
    throw "bad player";
    return 0;
 }
 void player(void* param)
 {
    boost::mutex::scoped_lock lock(mutex);
    int active = (int)param;
    int other = active == PLAYER_A ? PLAYER_B : PLAYER_A;
    while (state < GAME_OVER)
    {
        std::cout << player_name(active) << ": Play." << std::endl;
        state = other;
        cond.notify_all();
        do
        {
            cond.wait(lock);
            if (state == other)
                std::cout << "---" << player_name(active) << ": Spurious wakeup!" << std::endl;
        } while (state == other);
    }
    ++state;
    std::cout << player_name(active) << ": Gone." << std::endl;
    cond.notify_all();
 }
 struct thread_adapt
 {
    thread_adapt(void (*func)(void*), void* param) : _func(func), _param(param) { }
    int operator()() const
    {
        _func(_param);
        return 0;
    }
    void (*_func)(void*);
    void* _param;
 };
 class thread_adapter
 {
 public:
    thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
    void operator()() const { _func(_param); }
 private:
    void (*_func)(void*);
    void* _param;
 };
 int main(int argc, char* argv[])
 {
    state = START;
    boost::thread thrda(thread_adapter(&player, (void*)PLAYER_A));
    boost::thread thrdb(thread_adapter(&player, (void*)PLAYER_B));
    boost::xtime xt;
    boost::xtime_get(&xt, boost::TIME_UTC);
    xt.sec += 1;
    boost::thread::sleep(xt);
    {
        boost::mutex::scoped_lock lock(mutex);
        std::cout << "---Noise ON..." << std::endl;
    }
    for (int i = 0; i < 1000000; ++i)
        cond.notify_all();
    {
        boost::mutex::scoped_lock lock(mutex);
        std::cout << "---Noise OFF..." << std::endl;
        state = GAME_OVER;
        cond.notify_all();
        do
        {
            cond.wait(lock);
        } while (state != BOTH_PLAYERS_GONE);
    }
    std::cout << "GAME OVER" << std::endl;
    thrda.join();
    thrdb.join();
    return 0;
 }
--- a/example/tennis/tennis.mcp
+++ b/example/tennis/tennis.mcp
--- a/include/boost/thread/condition.hpp
+++ b/include/boost/thread/condition.hpp
@@ -0,0 +1,170 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_CONDITION_WEK070601_HPP
 #define BOOST_CONDITION_WEK070601_HPP
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 #   error   Thread support is unavailable!
 #endif
 #include <boost/thread/exceptions.hpp>
 #include <boost/utility.hpp>
 #include <boost/thread/detail/lock.hpp>
 #if defined(BOOST_HAS_PTHREADS)
 #   include <pthread.h>
 #elif defined(BOOST_HAS_MPTASKS)
 #   include "scoped_critical_region.hpp"
 #endif
 namespace boost {
 struct xtime;
 class condition : private noncopyable
 {
 public:
    condition();
    ~condition();
    void notify_one();
    void notify_all();
    template <typename L>
    void wait(L& lock)
    {
        if (!lock)
            throw lock_error();
        do_wait(lock.m_mutex);
    }
    template <typename L, typename Pr>
    void wait(L& lock, Pr pred)
    {
        if (!lock)
            throw lock_error();
        while (!pred())
            do_wait(lock.m_mutex);
    }
    template <typename L>
    bool timed_wait(L& lock, const xtime& xt)
    {
        if (!lock)
            throw lock_error();
        return do_timed_wait(lock.m_mutex, xt);
    }
    template <typename L, typename Pr>
    bool timed_wait(L& lock, const xtime& xt, Pr pred)
    {
        if (!lock)
            throw lock_error();
        while (!pred())
        {
            if (!do_timed_wait(lock.m_mutex, xt))
                return false;
        }
        return true;
    }
 private:
    template <typename M>
    void do_wait(M& mutex)
    {
 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
        enter_wait();
 #endif
        typedef typename detail::thread::lock_ops<M> lock_ops;
        typename lock_ops::lock_state state;
        lock_ops::unlock(mutex, state);
 #if defined(BOOST_HAS_PTHREADS)
        do_wait(state.pmutex);
 #elif (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
        do_wait();
 #endif
        lock_ops::lock(mutex, state);
    }
    template <typename M>
    bool do_timed_wait(M& mutex, const xtime& xt)
    {
 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
        enter_wait();
 #endif
        typedef typename detail::thread::lock_ops<M> lock_ops;
        typename lock_ops::lock_state state;
        lock_ops::unlock(mutex, state);
        bool ret = false;
 #if defined(BOOST_HAS_PTHREADS)
        ret = do_timed_wait(xt, state.pmutex);
 #elif (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
        ret = do_timed_wait(xt);
 #endif
        lock_ops::lock(mutex, state);
        return ret;
    }
 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
    void enter_wait();
    void do_wait();
    bool do_timed_wait(const xtime& xt);
 #elif defined(BOOST_HAS_PTHREADS)
    void do_wait(pthread_mutex_t* pmutex);
    bool do_timed_wait(const xtime& xt, pthread_mutex_t* pmutex);
 #endif
 #if defined(BOOST_HAS_WINTHREADS)
    void* m_gate;
    void* m_queue;
    void* m_mutex;
    unsigned m_gone; // # threads that timed out and never made it to the m_queue
    unsigned long m_blocked; // # threads m_blocked m_waiting for the condition
    unsigned m_waiting; // # threads m_waiting no longer m_waiting for the condition but still
                      //   m_waiting to be removed from the m_queue
 #elif defined(BOOST_HAS_PTHREADS)
    pthread_cond_t m_condition;
 #elif defined(BOOST_HAS_MPTASKS)
    MPSemaphoreID m_gate;
    MPSemaphoreID m_queue;
    threads::mac::detail::scoped_critical_region m_mutex;
    threads::mac::detail::scoped_critical_region m_mutex_mutex;
    unsigned m_gone; // # threads that timed out and never made it to the m_queue
    unsigned long m_blocked; // # threads m_blocked m_waiting for the condition
    unsigned m_waiting; // # threads m_waiting no longer m_waiting for the condition but still
                      //   m_waiting to be removed from the m_queue
 #endif
 };
 } // namespace boost
 // Change Log:
 //    8 Feb 01  WEKEMPF Initial version.
 //   22 May 01  WEKEMPF Modified to use xtime for time outs.
 //   23 May 01  WEKEMPF Removed "duration" timed_waits, as they are too difficult
 //                      to use with spurious wakeups.
 #endif // BOOST_CONDITION_WEK070601_HPP
--- a/include/boost/thread/detail/force_cast.hpp
+++ b/include/boost/thread/detail/force_cast.hpp
@@ -0,0 +1,44 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_FORCE_CAST_MJM012402_HPP
 #define BOOST_FORCE_CAST_MJM012402_HPP
 namespace boost {
 namespace detail {
 namespace thread {
 // force_cast will convert anything to anything.
 // general case
 template<class Return_Type, class Argument_Type>
 inline Return_Type &force_cast(Argument_Type &rSrc)
    {   return(*reinterpret_cast<Return_Type *>(&rSrc));    }
 // specialization for const
 template<class Return_Type, class Argument_Type>
 inline const Return_Type &force_cast(const Argument_Type &rSrc)
    {   return(*reinterpret_cast<const Return_Type *>(&rSrc));  }
 } // namespace thread
 } // namespace detail
 } // namespace boost
 #endif // BOOST_FORCE_CAST_MJM012402_HPP
--- a/include/boost/thread/detail/lock.hpp
+++ b/include/boost/thread/detail/lock.hpp
@@ -0,0 +1,207 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_XLOCK_WEK070601_HPP
 #define BOOST_XLOCK_WEK070601_HPP
 #include <boost/utility.hpp>
 #include <boost/thread/exceptions.hpp>
 namespace boost {
 class condition;
 struct xtime;
    namespace detail { namespace thread {
    template <typename Mutex>
    class lock_ops : private noncopyable
    {
    private:
        lock_ops() { }
    public:
        typedef typename Mutex::cv_state lock_state;
        static void lock(Mutex& m)
        {
            m.do_lock();
        }
        static bool trylock(Mutex& m)
        {
            return m.do_trylock();
        }
        static bool timedlock(Mutex& m, const xtime& xt)
        {
            return m.do_timedlock(xt);
        }
        static void unlock(Mutex& m)
        {
            m.do_unlock();
        }
        static void lock(Mutex& m, lock_state& state)
        {
            m.do_lock(state);
        }
        static void unlock(Mutex& m, lock_state& state)
        {
            m.do_unlock(state);
        }
    };
    template <typename Mutex>
    class scoped_lock : private noncopyable
    {
    public:
        typedef Mutex mutex_type;
        explicit scoped_lock(Mutex& mx, bool initially_locked=true)
            : m_mutex(mx), m_locked(false)
        {
            if (initially_locked) lock();
        }
        ~scoped_lock()
        {
            if (m_locked) unlock();
        }
        void lock()
        {
            if (m_locked) throw lock_error();
            lock_ops<Mutex>::lock(m_mutex);
            m_locked = true;
        }
        void unlock()
        {
            if (!m_locked) throw lock_error();
            lock_ops<Mutex>::unlock(m_mutex);
            m_locked = false;
        }
        bool locked() const { return m_locked; }
        operator const void*() const { return m_locked ? this : 0; }
    private:
        friend class boost::condition;
        Mutex& m_mutex;
        bool m_locked;
    };
    template <typename TryMutex>
    class scoped_try_lock : private noncopyable
    {
    public:
        typedef TryMutex mutex_type;
        explicit scoped_try_lock(TryMutex& mx)
            : m_mutex(mx), m_locked(false)
        {
            try_lock();
        }
        scoped_try_lock(TryMutex& mx, bool initially_locked)
            : m_mutex(mx), m_locked(false)
        {
            if (initially_locked) lock();
        }
        ~scoped_try_lock()
        {
            if (m_locked) unlock();
        }
        void lock()
        {
            if (m_locked) throw lock_error();
            lock_ops<TryMutex>::lock(m_mutex);
            m_locked = true;
        }
        bool try_lock()
        {
            if (m_locked) throw lock_error();
            return (m_locked = lock_ops<TryMutex>::trylock(m_mutex));
        }
        void unlock()
        {
            if (!m_locked) throw lock_error();
            lock_ops<TryMutex>::unlock(m_mutex);
            m_locked = false;
        }
        bool locked() const { return m_locked; }
        operator const void*() const { return m_locked ? this : 0; }
    private:
        friend class boost::condition;
        TryMutex& m_mutex;
        bool m_locked;
    };
    template <typename TimedMutex>
    class scoped_timed_lock : private noncopyable
    {
    public:
        typedef TimedMutex mutex_type;
        scoped_timed_lock(TimedMutex& mx, const xtime& xt)
            : m_mutex(mx), m_locked(false)
        {
            timed_lock(xt);
        }
        scoped_timed_lock(TimedMutex& mx, bool initially_locked)
            : m_mutex(mx), m_locked(false)
        {
            if (initially_locked) lock();
        }
        ~scoped_timed_lock()
        {
            if (m_locked) unlock();
        }
        void lock()
        {
            if (m_locked) throw lock_error();
            lock_ops<TimedMutex>::lock(m_mutex);
            m_locked = true;
        }
        bool timed_lock(const xtime& xt)
        {
            if (m_locked) throw lock_error();
            return (m_locked = lock_ops<TimedMutex>::timedlock(m_mutex, xt));
        }
        void unlock()
        {
            if (!m_locked) throw lock_error();
            lock_ops<TimedMutex>::unlock(m_mutex);
            m_locked = false;
        }
        bool locked() const { return m_locked; }
        operator const void*() const { return m_locked ? this : 0; }
    private:
        friend class boost::condition;
        TimedMutex& m_mutex;
        bool m_locked;
    };
    } // namespace thread
    } // namespace detail
 } // namespace boost
 // Change Log:
 //    8 Feb 01  WEKEMPF Initial version.
 //   22 May 01  WEKEMPF Modified to use xtime for time outs.
 //   30 Jul 01  WEKEMPF Moved lock types into boost::detail::thread. Renamed some types.
 //                      Added locked() methods.
 #endif // BOOST_XLOCK_WEK070601_HPP
--- a/include/boost/thread/detail/singleton.hpp
+++ b/include/boost/thread/detail/singleton.hpp
@@ -0,0 +1,64 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_SINGLETON_MJM012402_HPP
 #define BOOST_SINGLETON_MJM012402_HPP
 namespace boost {
 namespace detail {
 namespace thread {
 // class singleton has the same goal as all singletons: create one instance of a
 //  class on demand, then dish it out as requested.
 template<class T>
 class singleton: private T
 {
  private:
    singleton();
    ~singleton();
  public:
    static T &instance();
 };
 template<class T>
 inline singleton<T>::singleton()
    {   /* no-op */ }
 template<class T>
 inline singleton<T>::~singleton()
    {   /* no-op */ }
 template<class T>
 /*static*/ T &singleton<T>::instance()
 {
 // function-local static to force this to work correctly at static initialization
 //  time.
    static singleton<T> s_oT;
    return(s_oT);
 }
 } // namespace thread
 } // namespace detail
 } // namespace boost
 #endif // BOOST_SINGLETON_MJM012402_HPP
--- a/include/boost/thread/exceptions.hpp
+++ b/include/boost/thread/exceptions.hpp
@@ -0,0 +1,39 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_THREAD_EXCEPTIONS_PDM070801_H
 #define BOOST_THREAD_EXCEPTIONS_PDM070801_H
 //  pdm: Sorry, but this class is used all over the place & I end up
 //       with recursive headers if I don't separate it
 //  wek: Not sure why recursive headers would cause compilation problems
 //       given the include guards, but regardless it makes sense to
 //       seperate this out any way.
 #include <stdexcept>
 namespace boost {
 class lock_error : public std::logic_error
 {
 public:
    lock_error();
 };
 class thread_resource_error : public std::runtime_error
 {
 public:
    thread_resource_error();
 };
 } // namespace boost
 #endif // BOOST_THREAD_CONFIG_PDM070801_H
--- a/include/boost/thread/mutex.hpp
+++ b/include/boost/thread/mutex.hpp
@@ -0,0 +1,164 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_MUTEX_WEK070601_HPP
 #define BOOST_MUTEX_WEK070601_HPP
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 #   error   Thread support is unavailable!
 #endif
 #include <boost/utility.hpp>
 #include <boost/thread/detail/lock.hpp>
 #if defined(BOOST_HAS_PTHREADS)
 #   include <pthread.h>
 #endif
 #if defined(BOOST_HAS_MPTASKS)
 #   include "scoped_critical_region.hpp"
 #endif
 namespace boost {
 struct xtime;
 class mutex : private noncopyable
 {
 public:
    friend class detail::thread::lock_ops<mutex>;
    typedef detail::thread::scoped_lock<mutex> scoped_lock;
    mutex();
    ~mutex();
 private:
 #if defined(BOOST_HAS_WINTHREADS)
    typedef void* cv_state;
 #elif defined(BOOST_HAS_PTHREADS)
    struct cv_state
    {
        pthread_mutex_t* pmutex;
    };
 #elif defined(BOOST_HAS_MPTASKS)
    struct cv_state
    {
    };
 #endif
    void do_lock();
    void do_unlock();
    void do_lock(cv_state& state);
    void do_unlock(cv_state& state);
 #if defined(BOOST_HAS_WINTHREADS)
    void* m_mutex;
 #elif defined(BOOST_HAS_PTHREADS)
    pthread_mutex_t m_mutex;
 #elif defined(BOOST_HAS_MPTASKS)
    threads::mac::detail::scoped_critical_region m_mutex;
    threads::mac::detail::scoped_critical_region m_mutex_mutex;
 #endif
 };
 class try_mutex : private noncopyable
 {
 public:
    friend class detail::thread::lock_ops<try_mutex>;
    typedef detail::thread::scoped_lock<try_mutex> scoped_lock;
    typedef detail::thread::scoped_try_lock<try_mutex> scoped_try_lock;
    try_mutex();
    ~try_mutex();
 private:
 #if defined(BOOST_HAS_WINTHREADS)
    typedef void* cv_state;
 #elif defined(BOOST_HAS_PTHREADS)
    struct cv_state
    {
        pthread_mutex_t* pmutex;
    };
 #elif defined(BOOST_HAS_MPTASKS)
    struct cv_state
    {
    };
 #endif
    void do_lock();
    bool do_trylock();
    void do_unlock();
    void do_lock(cv_state& state);
    void do_unlock(cv_state& state);
 #if defined(BOOST_HAS_WINTHREADS)
    void* m_mutex;
 #elif defined(BOOST_HAS_PTHREADS)
    pthread_mutex_t m_mutex;
 #elif defined(BOOST_HAS_MPTASKS)
    threads::mac::detail::scoped_critical_region m_mutex;
    threads::mac::detail::scoped_critical_region m_mutex_mutex;
 #endif
 };
 class timed_mutex : private noncopyable
 {
 public:
    friend class detail::thread::lock_ops<timed_mutex>;
    typedef detail::thread::scoped_lock<timed_mutex> scoped_lock;
    typedef detail::thread::scoped_try_lock<timed_mutex> scoped_try_lock;
    typedef detail::thread::scoped_timed_lock<timed_mutex> scoped_timed_lock;
    timed_mutex();
    ~timed_mutex();
 private:
 #if defined(BOOST_HAS_WINTHREADS)
    typedef void* cv_state;
 #elif defined(BOOST_HAS_PTHREADS)
    struct cv_state
    {
        pthread_mutex_t* pmutex;
    };
 #elif defined(BOOST_HAS_MPTASKS)
    struct cv_state
    {
    };
 #endif
    void do_lock();
    bool do_trylock();
    bool do_timedlock(const xtime& xt);
    void do_unlock();
    void do_lock(cv_state& state);
    void do_unlock(cv_state& state);
 #if defined(BOOST_HAS_WINTHREADS)
    void* m_mutex;
 #elif defined(BOOST_HAS_PTHREADS)
    pthread_mutex_t m_mutex;
    pthread_cond_t m_condition;
    bool m_locked;
 #elif defined(BOOST_HAS_MPTASKS)
    threads::mac::detail::scoped_critical_region m_mutex;
    threads::mac::detail::scoped_critical_region m_mutex_mutex;
 #endif
 };
 } // namespace boost
 // Change Log:
 //    8 Feb 01  WEKEMPF Initial version.
 //   22 May 01  WEKEMPF Modified to use xtime for time outs.  Factored out
 //                      to three classes, mutex, try_mutex and timed_mutex.
 #endif // BOOST_MUTEX_WEK070601_HPP
--- a/include/boost/thread/once.hpp
+++ b/include/boost/thread/once.hpp
@@ -0,0 +1,45 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_ONCE_WEK080101_HPP
 #define BOOST_ONCE_WEK080101_HPP
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 #   error   Thread support is unavailable!
 #endif
 #if defined(BOOST_HAS_PTHREADS)
 #   include <pthread.h>
 #endif
 namespace boost {
 #if defined(BOOST_HAS_PTHREADS)
 typedef pthread_once_t once_flag;
 #define BOOST_ONCE_INIT PTHREAD_ONCE_INIT
 #elif (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
 typedef bool once_flag;
 #define BOOST_ONCE_INIT false
 #endif
 void call_once(void (*func)(), once_flag& flag);
 } // namespace boost
 // Change Log:
 //   1 Aug 01  WEKEMPF Initial version.
 #endif // BOOST_ONCE_WEK080101_HPP
--- a/include/boost/thread/recursive_mutex.hpp
+++ b/include/boost/thread/recursive_mutex.hpp
@@ -0,0 +1,174 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_RECURSIVE_MUTEX_WEK070601_HPP
 #define BOOST_RECURSIVE_MUTEX_WEK070601_HPP
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 #   error   Thread support is unavailable!
 #endif
 #include <boost/utility.hpp>
 #include <boost/thread/detail/lock.hpp>
 #if defined(BOOST_HAS_PTHREADS)
 #   include <pthread.h>
 #elif defined(BOOST_HAS_MPTASKS)
 #   include "scoped_critical_region.hpp"
 #endif
 namespace boost {
 struct xtime;
 class recursive_mutex : private noncopyable
 {
 public:
    friend class detail::thread::lock_ops<recursive_mutex>;
    typedef detail::thread::scoped_lock<recursive_mutex> scoped_lock;
    recursive_mutex();
    ~recursive_mutex();
 private:
 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
    typedef std::size_t cv_state;
 #elif defined(BOOST_HAS_PTHREADS)
    struct cv_state
    {
        long count;
        pthread_mutex_t* pmutex;
    };
 #endif
    void do_lock();
    void do_unlock();
    void do_lock(cv_state& state);
    void do_unlock(cv_state& state);
 #if defined(BOOST_HAS_WINTHREADS)
    void* m_mutex;
    unsigned long m_count;
 #elif defined(BOOST_HAS_PTHREADS)
    pthread_mutex_t m_mutex;
    unsigned m_count;
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    pthread_cond_t m_unlocked;
    pthread_t m_thread_id;
    bool m_valid_id;
 #   endif
 #elif defined(BOOST_HAS_MPTASKS)
    threads::mac::detail::scoped_critical_region m_mutex;
    threads::mac::detail::scoped_critical_region m_mutex_mutex;
    std::size_t m_count;
 #endif
 };
 class recursive_try_mutex : private noncopyable
 {
 public:
    friend class detail::thread::lock_ops<recursive_try_mutex>;
    typedef detail::thread::scoped_lock<recursive_try_mutex> scoped_lock;
    typedef detail::thread::scoped_try_lock<recursive_try_mutex> scoped_try_lock;
    recursive_try_mutex();
    ~recursive_try_mutex();
 private:
 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
    typedef std::size_t cv_state;
 #elif defined(BOOST_HAS_PTHREADS)
    struct cv_state
    {
        long count;
        pthread_mutex_t* pmutex;
    };
 #endif
    void do_lock();
    bool do_trylock();
    void do_unlock();
    void do_lock(cv_state& state);
    void do_unlock(cv_state& state);
 #if defined(BOOST_HAS_WINTHREADS)
    void* m_mutex;
    unsigned long m_count;
 #elif defined(BOOST_HAS_PTHREADS)
    pthread_mutex_t m_mutex;
    unsigned m_count;
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    pthread_cond_t m_unlocked;
    pthread_t m_thread_id;
    bool m_valid_id;
 #   endif
 #elif defined(BOOST_HAS_MPTASKS)
    threads::mac::detail::scoped_critical_region m_mutex;
    threads::mac::detail::scoped_critical_region m_mutex_mutex;
    std::size_t m_count;
 #endif
 };
 class recursive_timed_mutex : private noncopyable
 {
 public:
    friend class detail::thread::lock_ops<recursive_timed_mutex>;
    typedef detail::thread::scoped_lock<recursive_timed_mutex> scoped_lock;
    typedef detail::thread::scoped_try_lock<recursive_timed_mutex> scoped_try_lock;
    typedef detail::thread::scoped_timed_lock<recursive_timed_mutex> scoped_timed_lock;
    recursive_timed_mutex();
    ~recursive_timed_mutex();
 private:
 #if (defined(BOOST_HAS_WINTHREADS) || defined(BOOST_HAS_MPTASKS))
    typedef std::size_t cv_state;
 #elif defined(BOOST_HAS_PTHREADS)
    struct cv_state
    {
        long count;
        pthread_mutex_t* pmutex;
    };
 #endif
    void do_lock();
    bool do_trylock();
    bool do_timedlock(const xtime& xt);
    void do_unlock();
    void do_lock(cv_state& state);
    void do_unlock(cv_state& state);
 #if defined(BOOST_HAS_WINTHREADS)
    void* m_mutex;
    unsigned long m_count;
 #elif defined(BOOST_HAS_PTHREADS)
    pthread_mutex_t m_mutex;
    pthread_cond_t m_unlocked;
    pthread_t m_thread_id;
    bool m_valid_id;
    unsigned m_count;
 #elif defined(BOOST_HAS_MPTASKS)
    threads::mac::detail::scoped_critical_region m_mutex;
    threads::mac::detail::scoped_critical_region m_mutex_mutex;
    std::size_t m_count;
 #endif
 };
 } // namespace boost
 // Change Log:
 //    8 Feb 01  WEKEMPF Initial version.
 //    1 Jun 01  WEKEMPF Modified to use xtime for time outs.  Factored out
 //                      to three classes, mutex, try_mutex and timed_mutex.
 //   11 Jun 01  WEKEMPF Modified to use PTHREAD_MUTEX_RECURSIVE if available.
 #endif // BOOST_RECURSIVE_MUTEX_WEK070601_HPP
--- a/include/boost/thread/thread.hpp
+++ b/include/boost/thread/thread.hpp
@@ -0,0 +1,89 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_THREAD_WEK070601_HPP
 #define BOOST_THREAD_WEK070601_HPP
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 #   error   Thread support is unavailable!
 #endif
 #include <boost/utility.hpp>
 #include <boost/function.hpp>
 #include <boost/thread/mutex.hpp>
 #include <list>
 #include <memory>
 #if defined(BOOST_HAS_PTHREADS)
 #   include <pthread.h>
 #   include <boost/thread/condition.hpp>
 #elif defined(BOOST_HAS_MPTASKS)
 #   include <Multiprocessing.h>
 #endif
 namespace boost {
 struct xtime;
 class thread : private noncopyable
 {
 public:
    thread();
    explicit thread(const function0<void>& threadfunc);
    ~thread();
    bool operator==(const thread& other) const;
    bool operator!=(const thread& other) const;
    void join();
    static void sleep(const xtime& xt);
    static void yield();
 private:
 #if defined(BOOST_HAS_WINTHREADS)
    void* m_thread;
    unsigned int m_id;
 #elif defined(BOOST_HAS_PTHREADS)
 private:
    pthread_t m_thread;
 #elif defined(BOOST_HAS_MPTASKS)
    MPQueueID m_pJoinQueueID;
    MPTaskID m_pTaskID;
 #endif
    bool m_joinable;
 };
 class thread_group : private noncopyable
 {
 public:
    thread_group();
    ~thread_group();
    thread* create_thread(const function0<void>& threadfunc);
    void add_thread(thread* thrd);
    void remove_thread(thread* thrd);
    void join_all();
 private:
    std::list<thread*> m_threads;
    mutex m_mutex;
 };
 } // namespace boost
 // Change Log:
 //    8 Feb 01  WEKEMPF Initial version.
 //    1 Jun 01  WEKEMPF Added boost::thread initial implementation.
 //    3 Jul 01  WEKEMPF Redesigned boost::thread to be noncopyable.
 #endif // BOOST_THREAD_WEK070601_HPP
--- a/include/boost/thread/tss.hpp
+++ b/include/boost/thread/tss.hpp
@@ -0,0 +1,81 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_TSS_WEK070601_HPP
 #define BOOST_TSS_WEK070601_HPP
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 #   error   Thread support is unavailable!
 #endif
 #include <boost/utility.hpp>
 #if defined(BOOST_HAS_PTHREADS)
 #   include <pthread.h>
 #elif defined(BOOST_HAS_MPTASKS)
 #   include <Multiprocessing.h>
 #endif
 namespace boost {
    namespace detail {
        class tss : private noncopyable
        {
        public:
            tss(void (*cleanup)(void*)=0);
            ~tss();
            void* get() const;
            bool set(void* value);
        private:
        #if defined(BOOST_HAS_WINTHREADS)
            unsigned long m_key;
            void (*m_cleanup)(void*);
        #elif defined(BOOST_HAS_PTHREADS)
            pthread_key_t m_key;
        #elif defined(BOOST_HAS_MPTASKS)
            TaskStorageIndex m_key;
            void (*m_cleanup)(void*);
        #endif
        };
    #if defined(BOOST_HAS_MPTASKS)
        void thread_cleanup();
    #endif
    }
 template <typename T>
 class thread_specific_ptr : private noncopyable
 {
 public:
    thread_specific_ptr() : m_tss(&thread_specific_ptr<T>::cleanup) { }
    T* get() const { return static_cast<T*>(m_tss.get()); }
    T* operator->() const { return get(); }
    T& operator*() const { return *get(); }
    T* release() { T* temp = get(); m_tss.set(0); return temp; }
    void reset(T* p=0) { T* cur = get(); if (cur == p) return; delete cur; m_tss.set(p); }
 private:
    static void cleanup(void* p) { delete static_cast<T*>(p); }
    mutable detail::tss m_tss;
 };
 } // namespace boost
 // Change Log:
 //   6 Jun 01  WEKEMPF Initial version.
 #endif // BOOST_TSS_WEK070601_HPP
--- a/include/boost/thread/xtime.hpp
+++ b/include/boost/thread/xtime.hpp
@@ -0,0 +1,57 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #ifndef BOOST_XTIME_WEK070601_HPP
 #define BOOST_XTIME_WEK070601_HPP
 #include <boost/cstdint.hpp>
 #include <boost/config.hpp>
 namespace boost {
 enum
 {
    TIME_UTC=1,
    TIME_TAI,
    TIME_MONOTONIC,
    TIME_PROCESS,
    TIME_THREAD,
    TIME_LOCAL,
    TIME_SYNC,
    TIME_RESOLUTION
 };
 struct xtime
 {
 #if defined(BOOST_NO_INT64_T)
    int_fast32_t sec;
 #else
    int_fast64_t sec;
 #endif
    int_fast32_t nsec;
 };
 int xtime_get(struct xtime* xtp, int clock_type);
 inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
 {
 	int res = (int)(xt1.sec - xt2.sec);
 	if (res == 0)
 		res = (int)(xt1.nsec - xt2.nsec);
 	return res;
 }
 } // namespace boost
 // Change Log:
 //   8 Feb 01  WEKEMPF Initial version.
 #endif // BOOST_XTIME_WEK070601_HPP
--- a/src/condition.cpp
+++ b/src/condition.cpp
@@ -0,0 +1,646 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #include <boost/thread/condition.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <boost/limits.hpp>
 #include <cassert>
 #include "timeconv.inl"
 #if defined(BOOST_HAS_WINTHREADS)
 #   ifndef NOMINMAX
 #      define NOMINMAX
 #   endif
 #   include <windows.h>
 #elif defined(BOOST_HAS_PTHREADS)
 #   include <errno.h>
 #elif defined(BOOST_HAS_MPTASKS)
 #    include <MacErrors.h>
 #    include "mac/init.hpp"
 #    include "mac/safe.hpp"
 #endif
 namespace boost {
 #if defined(BOOST_HAS_WINTHREADS)
 condition::condition()
    : m_gone(0), m_blocked(0), m_waiting(0)
 {
    m_gate = reinterpret_cast<void*>(CreateSemaphore(0, 1, 1, 0));
    m_queue = reinterpret_cast<void*>(CreateSemaphore(0, 0, std::numeric_limits<long>::max(), 0));
    m_mutex = reinterpret_cast<void*>(CreateMutex(0, 0, 0));
    if (!m_gate || !m_queue || !m_mutex)
    {
        int res = 0;
        if (m_gate)
        {
            res = CloseHandle(reinterpret_cast<HANDLE>(m_gate));
            assert(res);
        }
        if (m_queue)
        {
            res = CloseHandle(reinterpret_cast<HANDLE>(m_queue));
            assert(res);
        }
        if (m_mutex)
        {
            res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
            assert(res);
        }
        throw thread_resource_error();
    }
 }
 condition::~condition()
 {
    int res = 0;
    res = CloseHandle(reinterpret_cast<HANDLE>(m_gate));
    assert(res);
    res = CloseHandle(reinterpret_cast<HANDLE>(m_queue));
    assert(res);
    res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 void condition::notify_one()
 {
    unsigned signals = 0;
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
    if (m_waiting != 0) // the m_gate is already closed
    {
        if (m_blocked == 0)
        {
            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
            assert(res);
            return;
        }
        ++m_waiting;
        --m_blocked;
        signals = 1;
    }
    else
    {
        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
        assert(res == WAIT_OBJECT_0);
        if (m_blocked > m_gone)
        {
            if (m_gone != 0)
            {
                m_blocked -= m_gone;
                m_gone = 0;
            }
            signals = m_waiting = 1;
            --m_blocked;
        }
        else
        {
            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
            assert(res);
        }
    }
    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
    if (signals)
    {
        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
        assert(res);
    }
 }
 void condition::notify_all()
 {
    unsigned signals = 0;
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
    if (m_waiting != 0) // the m_gate is already closed
    {
        if (m_blocked == 0)
        {
            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
            assert(res);
            return;
        }
        m_waiting += (signals = m_blocked);
        m_blocked = 0;
    }
    else
    {
        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
        assert(res == WAIT_OBJECT_0);
        if (m_blocked > m_gone)
        {
            if (m_gone != 0)
            {
                m_blocked -= m_gone;
                m_gone = 0;
            }
            signals = m_waiting = m_blocked;
            m_blocked = 0;
        }
        else
        {
            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
            assert(res);
        }
        res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
        assert(res);
        if (signals)
        {
            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
            assert(res);
        }
    }
 }
 void condition::enter_wait()
 {
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
    assert(res == WAIT_OBJECT_0);
    ++m_blocked;
    res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
    assert(res);
 }
 void condition::do_wait()
 {
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), INFINITE);
    assert(res == WAIT_OBJECT_0);
    unsigned was_waiting=0;
    unsigned was_gone=0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
    was_waiting = m_waiting;
    was_gone = m_gone;
    if (was_waiting != 0)
    {
        if (--m_waiting == 0)
        {
            if (m_blocked != 0)
            {
                res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0); // open m_gate
                assert(res);
                was_waiting = 0;
            }
            else if (m_gone != 0)
                m_gone = 0;
        }
    }
    else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
    {
        // timeout occured, normalize the m_gone count
        // this may occur if many calls to wait with a timeout are made and
        // no call to notify_* is made
        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
        assert(res == WAIT_OBJECT_0);
        m_blocked -= m_gone;
        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
        assert(res);
        m_gone = 0;
    }
    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
    if (was_waiting == 1)
    {
        for (/**/ ; was_gone; --was_gone)
        {
            // better now than spurious later
            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), INFINITE);
            assert(res == WAIT_OBJECT_0);
        }
        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
        assert(res);
    }
 }
 bool condition::do_timed_wait(const xtime& xt)
 {
    int milliseconds;
    to_duration(xt, milliseconds);
    unsigned int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), milliseconds);
    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
    bool ret = (res == WAIT_OBJECT_0);
    unsigned was_waiting=0;
    unsigned was_gone=0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
    was_waiting = m_waiting;
    was_gone = m_gone;
    if (was_waiting != 0)
    {
        if (!ret) // timeout
        {
            if (m_blocked != 0)
                --m_blocked;
            else
                ++m_gone; // count spurious wakeups
        }
        if (--m_waiting == 0)
        {
            if (m_blocked != 0)
            {
                res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0); // open m_gate
                assert(res);
                was_waiting = 0;
            }
            else if (m_gone != 0)
                m_gone = 0;
        }
    }
    else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
    {
        // timeout occured, normalize the m_gone count
        // this may occur if many calls to wait with a timeout are made and
        // no call to notify_* is made
        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
        assert(res == WAIT_OBJECT_0);
        m_blocked -= m_gone;
        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
        assert(res);
        m_gone = 0;
    }
    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
    if (was_waiting == 1)
    {
        for (/**/ ; was_gone; --was_gone)
        {
            // better now than spurious later
            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), INFINITE);
            assert(res ==  WAIT_OBJECT_0);
        }
        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
        assert(res);
    }
    return ret;
 }
 #elif defined(BOOST_HAS_PTHREADS)
 condition::condition()
 {
    int res = 0;
    res = pthread_cond_init(&m_condition, 0);
    if (res != 0)
        throw thread_resource_error();
 }
 condition::~condition()
 {
    int res = 0;
    res = pthread_cond_destroy(&m_condition);
    assert(res == 0);
 }
 void condition::notify_one()
 {
    int res = 0;
    res = pthread_cond_signal(&m_condition);
    assert(res == 0);
 }
 void condition::notify_all()
 {
    int res = 0;
    res = pthread_cond_broadcast(&m_condition);
    assert(res == 0);
 }
 void condition::do_wait(pthread_mutex_t* pmutex)
 {
    int res = 0;
    res = pthread_cond_wait(&m_condition, pmutex);
    assert(res == 0);
 }
 bool condition::do_timed_wait(const xtime& xt, pthread_mutex_t* pmutex)
 {
    timespec ts;
    to_timespec(xt, ts);
    int res = 0;
    res = pthread_cond_timedwait(&m_condition, pmutex, &ts);
    assert(res == 0 || res == ETIMEDOUT);
    return res != ETIMEDOUT;
 }
 #elif defined(BOOST_HAS_MPTASKS)
 using threads::mac::detail::safe_enter_critical_region;
 using threads::mac::detail::safe_wait_on_semaphore;
 condition::condition()
    : m_gone(0), m_blocked(0), m_waiting(0)
 {
    threads::mac::detail::thread_init();
    OSStatus lStatus = noErr;
    lStatus = MPCreateSemaphore(1, 1, &m_gate);
    if(lStatus == noErr)
        lStatus = MPCreateSemaphore(ULONG_MAX, 0, &m_queue);
    if(lStatus != noErr || !m_gate || !m_queue)
    {
        if (m_gate)
        {
            lStatus = MPDeleteSemaphore(m_gate);
            assert(lStatus == noErr);
        }
        if (m_queue)
        {
            lStatus = MPDeleteSemaphore(m_queue);
            assert(lStatus == noErr);
        }
        throw thread_resource_error();
    }
 }
 condition::~condition()
 {
    OSStatus lStatus = noErr;
    lStatus = MPDeleteSemaphore(m_gate);
    assert(lStatus == noErr);
    lStatus = MPDeleteSemaphore(m_queue);
    assert(lStatus == noErr);
 }
 void condition::notify_one()
 {
    unsigned signals = 0;
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    if (m_waiting != 0) // the m_gate is already closed
    {
        if (m_blocked == 0)
        {
            lStatus = MPExitCriticalRegion(m_mutex);
            assert(lStatus == noErr);
            return;
        }
        ++m_waiting;
        --m_blocked;
    }
    else
    {
        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
        assert(lStatus == noErr);
        if (m_blocked > m_gone)
        {
            if (m_gone != 0)
            {
                m_blocked -= m_gone;
                m_gone = 0;
            }
            signals = m_waiting = 1;
            --m_blocked;
        }
        else
        {
            lStatus = MPSignalSemaphore(m_gate);
            assert(lStatus == noErr);
        }
        lStatus = MPExitCriticalRegion(m_mutex);
        assert(lStatus == noErr);
        while (signals)
        {
            lStatus = MPSignalSemaphore(m_queue);
            assert(lStatus == noErr);
            --signals;
        }
    }
 }
 void condition::notify_all()
 {
    unsigned signals = 0;
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    if (m_waiting != 0) // the m_gate is already closed
    {
        if (m_blocked == 0)
        {
            lStatus = MPExitCriticalRegion(m_mutex);
            assert(lStatus == noErr);
            return;
        }
        m_waiting += (signals = m_blocked);
        m_blocked = 0;
    }
    else
    {
        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
        assert(lStatus == noErr);
        if (m_blocked > m_gone)
        {
            if (m_gone != 0)
            {
                m_blocked -= m_gone;
                m_gone = 0;
            }
            signals = m_waiting = m_blocked;
            m_blocked = 0;
        }
        else
        {
            lStatus = MPSignalSemaphore(m_gate);
            assert(lStatus == noErr);
        }
        lStatus = MPExitCriticalRegion(m_mutex);
        assert(lStatus == noErr);
        while (signals)
        {
            lStatus = MPSignalSemaphore(m_queue);
            assert(lStatus == noErr);
            --signals;
        }
    }
 }
 void condition::enter_wait()
 {
    OSStatus lStatus = noErr;
    lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
    assert(lStatus == noErr);
    ++m_blocked;
    lStatus = MPSignalSemaphore(m_gate);
    assert(lStatus == noErr);
 }
 void condition::do_wait()
 {
    OSStatus lStatus = noErr;
    lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
    assert(lStatus == noErr);
    unsigned was_waiting=0;
    unsigned was_gone=0;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    was_waiting = m_waiting;
    was_gone = m_gone;
    if (was_waiting != 0)
    {
        if (--m_waiting == 0)
        {
            if (m_blocked != 0)
            {
                lStatus = MPSignalSemaphore(m_gate); // open m_gate
                assert(lStatus == noErr);
                was_waiting = 0;
            }
            else if (m_gone != 0)
                m_gone = 0;
        }
    }
    else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
    {
        // timeout occured, normalize the m_gone count
        // this may occur if many calls to wait with a timeout are made and
        // no call to notify_* is made
        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
        assert(lStatus == noErr);
        m_blocked -= m_gone;
        lStatus = MPSignalSemaphore(m_gate);
        assert(lStatus == noErr);
        m_gone = 0;
    }
    lStatus = MPExitCriticalRegion(m_mutex);
    assert(lStatus == noErr);
    if (was_waiting == 1)
    {
        for (/**/ ; was_gone; --was_gone)
        {
            // better now than spurious later
            lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
            assert(lStatus == noErr);
        }
        lStatus = MPSignalSemaphore(m_gate);
        assert(lStatus == noErr);
    }
 }
 bool condition::do_timed_wait(const xtime& xt)
 {
    int milliseconds;
    to_duration(xt, milliseconds);
    OSStatus lStatus = noErr;
    lStatus = safe_wait_on_semaphore(m_queue, milliseconds);
    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
    bool ret = (lStatus == noErr);
    unsigned was_waiting=0;
    unsigned was_gone=0;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    was_waiting = m_waiting;
    was_gone = m_gone;
    if (was_waiting != 0)
    {
        if (!ret) // timeout
        {
            if (m_blocked != 0)
                --m_blocked;
            else
                ++m_gone; // count spurious wakeups
        }
        if (--m_waiting == 0)
        {
            if (m_blocked != 0)
            {
                lStatus = MPSignalSemaphore(m_gate); // open m_gate
                assert(lStatus == noErr);
                was_waiting = 0;
            }
            else if (m_gone != 0)
                m_gone = 0;
        }
    }
    else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
    {
        // timeout occured, normalize the m_gone count
        // this may occur if many calls to wait with a timeout are made and
        // no call to notify_* is made
        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
        assert(lStatus == noErr);
        m_blocked -= m_gone;
        lStatus = MPSignalSemaphore(m_gate);
        assert(lStatus == noErr);
        m_gone = 0;
    }
    lStatus = MPExitCriticalRegion(m_mutex);
    assert(lStatus == noErr);
    if (was_waiting == 1)
    {
        for (/**/ ; was_gone; --was_gone)
        {
            // better now than spurious later
            lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
            assert(lStatus == noErr);
        }
        lStatus = MPSignalSemaphore(m_gate);
        assert(lStatus == noErr);
    }
    return ret;
 }
 #endif
 } // namespace boost
 // Change Log:
 //    8 Feb 01  WEKEMPF Initial version.
 //   22 May 01  WEKEMPF Modified to use xtime for time outs.
--- a/src/exceptions.cpp
+++ b/src/exceptions.cpp
@@ -0,0 +1,25 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #include <boost/thread/exceptions.hpp>
 #include <string>
 namespace boost {
 lock_error::lock_error() : std::logic_error("thread lock error")
 {
 }
 thread_resource_error::thread_resource_error() : std::runtime_error("thread resource error")
 {
 }
 } // namespace boost
--- a/src/mac/debug_prefix.hpp
+++ b/src/mac/debug_prefix.hpp
@@ -0,0 +1,14 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #define TARGET_CARBON    1
--- a/src/mac/delivery_man.cpp
+++ b/src/mac/delivery_man.cpp
@@ -0,0 +1,72 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "delivery_man.hpp"
 #include "os.hpp"
 #include "execution_context.hpp"
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 delivery_man::delivery_man():
    m_pPackage(NULL),
    m_pSemaphore(kInvalidID),
    m_bPackageWaiting(false)
 {
    assert(at_st());
    OSStatus lStatus = MPCreateSemaphore(1UL, 0UL, &m_pSemaphore);
 // TODO - throw on error here
    assert(lStatus == noErr);
 }
 delivery_man::~delivery_man()
 {
    assert(m_bPackageWaiting == false);
    OSStatus lStatus = MPDeleteSemaphore(m_pSemaphore);
    assert(lStatus == noErr);
 }
 void delivery_man::accept_deliveries()
 {
    if(m_bPackageWaiting)
    {
        assert(m_pPackage != NULL);
        m_pPackage->accept();
        m_pPackage = NULL;
        m_bPackageWaiting = false;
    // signal to the thread making the call that we're done
        OSStatus lStatus = MPSignalSemaphore(m_pSemaphore);
        assert(lStatus == noErr);
    }
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/delivery_man.hpp
+++ b/src/mac/delivery_man.hpp
@@ -0,0 +1,90 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_DELIVERY_MAN_MJM012402_HPP
 #define BOOST_DELIVERY_MAN_MJM012402_HPP
 #include <boost/function.hpp>
 #include <boost/utility.hpp>
 #include <boost/thread/mutex.hpp>
 #include "package.hpp"
 #include <Multiprocessing.h>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 // class delivery_man is intended to move boost::function objects from MP tasks to
 //    other execution contexts (such as deferred task time or system task time).
 class delivery_man: private noncopyable
 {
  public:
    delivery_man();
    ~delivery_man();
  public:
    template<class R>
    R deliver(function<R> &rFunctor);
    void accept_deliveries();
  private:
    base_package *m_pPackage;
    mutex m_oMutex;
    MPSemaphoreID m_pSemaphore;
    bool m_bPackageWaiting;
 };
 template<class R>
 R delivery_man::deliver(function<R> &rFunctor)
 {
    assert(at_mp());
 // lock our mutex
    mutex::scoped_lock oLock(m_oMutex);
 // create a package and save it
    package<R> oPackage(rFunctor);
    m_pPackage = &oPackage;
    m_bPackageWaiting = true;
 // wait on the semaphore
    OSStatus lStatus = MPWaitOnSemaphore(m_pSemaphore, kDurationForever);
    assert(lStatus == noErr);
    return(oPackage.return_value());
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_DELIVERY_MAN_MJM012402_HPP
--- a/src/mac/dt_scheduler.cpp
+++ b/src/mac/dt_scheduler.cpp
@@ -0,0 +1,99 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "dt_scheduler.hpp"
 #include "ot_context.hpp"
 #include <boost/thread/detail/singleton.hpp>
 #include <OpenTransportProtocol.h>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 const OTTimeout k_ulTimerTaskDelay = 1UL;
 dt_scheduler::dt_scheduler():
    m_bReschedule(false),
    m_uppTask(NULL),
    m_lTask(0UL)
 {
    using ::boost::detail::thread::singleton;
    ot_context &rContext(singleton<ot_context>::instance());
    m_uppTask = NewOTProcessUPP(task_entry);
    m_lTask = OTCreateTimerTaskInContext(m_uppTask, this, rContext.get_context());
 }
 dt_scheduler::~dt_scheduler()
 {
    OTDestroyTimerTask(m_lTask);
    m_lTask = 0UL;
    DisposeOTProcessUPP(m_uppTask);
    m_uppTask = NULL;
 }
 void dt_scheduler::start_polling()
 {
    m_bReschedule = true;
    schedule_task();
 }
 void dt_scheduler::stop_polling()
 {
    m_bReschedule = false;
 }
 void dt_scheduler::schedule_task()
 {
    if(m_bReschedule)
    {
        OTScheduleTimerTask(m_lTask, k_ulTimerTaskDelay);
    }
 }
 /*static*/ pascal void dt_scheduler::task_entry(void *pRefCon)
 {
    dt_scheduler *pThis = reinterpret_cast<dt_scheduler *>(pRefCon);
    assert(pThis != NULL);
    pThis->task();
 }
 void dt_scheduler::task()
 {
    periodic_function();
    schedule_task();
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/dt_scheduler.hpp
+++ b/src/mac/dt_scheduler.hpp
@@ -0,0 +1,69 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_DT_SCHEDULER_MJM012402_HPP
 #define BOOST_DT_SCHEDULER_MJM012402_HPP
 #include "periodical.hpp"
 #include <OpenTransport.h>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 // class dt_scheduler calls its pure-virtual periodic_function method periodically at
 //    deferred task time.  This is generally 1kHz under Mac OS 9.
 class dt_scheduler
 {
  public:
    dt_scheduler();
    virtual ~dt_scheduler();
  protected:
    void start_polling();
    void stop_polling();
  private:
    virtual void periodic_function() = 0;
  private:
    void schedule_task();
    static pascal void task_entry(void *pRefCon);
    void task();
  private:
    bool m_bReschedule;
    OTProcessUPP m_uppTask;
    long m_lTask;
 };
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_DT_SCHEDULER_MJM012402_HPP
--- a/src/mac/execution_context.cpp
+++ b/src/mac/execution_context.cpp
@@ -0,0 +1,66 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include <Debugging.h>
 #include <Multiprocessing.h>
 #include "execution_context.hpp"
 #include "init.hpp"
 namespace boost {
 namespace threads {
 namespace mac {
 execution_context_t execution_context()
 {
 // make sure that MP services are available the first time through
    static bool bIgnored = detail::thread_init();
 // first check if we're an MP task
    if(MPTaskIsPreemptive(kInvalidID))
    {
        return(k_eExecutionContextMPTask);
    }
 #if TARGET_CARBON
 // Carbon has TaskLevel
    UInt32 ulLevel = TaskLevel();
    if(ulLevel == 0UL)
    {
        return(k_eExecutionContextSystemTask);
    }
    if(ulLevel & kInDeferredTaskMask)
    {
        return(k_eExecutionContextDeferredTask);
    }
    return(k_eExecutionContextOther);
 #else
 // this can be implemented using TaskLevel if you don't mind linking against
 //    DebugLib (and therefore breaking Mac OS 8.6 support), or CurrentExecutionLevel.
 #    error execution_context unimplimented
 #endif
 }
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/execution_context.hpp
+++ b/src/mac/execution_context.hpp
@@ -0,0 +1,53 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_EXECUTION_CONTEXT_MJM012402_HPP
 #define BOOST_EXECUTION_CONTEXT_MJM012402_HPP
 namespace boost {
 namespace threads {
 namespace mac {
 // utility functions for figuring out what context your code is executing in.
 //    Bear in mind that at_mp and in_blue are the only functions guarenteed by
 //    Apple to work.  There is simply no way of being sure that you will not get
 //    false readings about task level at interrupt time in blue.
 typedef enum {
    k_eExecutionContextSystemTask,
    k_eExecutionContextDeferredTask,
    k_eExecutionContextMPTask,
    k_eExecutionContextOther
 } execution_context_t;
 execution_context_t execution_context();
 inline bool at_st()
    {    return(execution_context() == k_eExecutionContextSystemTask);    }
 inline bool at_mp()
    {    return(execution_context() == k_eExecutionContextMPTask);        }
 inline bool in_blue()
    {    return(!at_mp());                                                }
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_EXECUTION_CONTEXT_MJM012402_HPP
--- a/src/mac/init.cpp
+++ b/src/mac/init.cpp
@@ -0,0 +1,64 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "init.hpp"
 #include "remote_call_manager.hpp"
 #include <boost/thread/detail/singleton.hpp>
 #include <Multiprocessing.h>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 namespace {
 // force these to get called by the end of static initialization time.
 static bool g_bInitialized = (thread_init() && create_singletons());
 }
 bool thread_init()
 {
    static bool bResult = MPLibraryIsLoaded();
    return(bResult);
 }
 bool create_singletons()
 {
    using ::boost::detail::thread::singleton;
    singleton<remote_call_manager>::instance();
    return(true);
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/init.hpp
+++ b/src/mac/init.hpp
@@ -0,0 +1,40 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_INIT_MJM012402_HPP
 #define BOOST_INIT_MJM012402_HPP
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 bool thread_init();
 bool create_singletons();
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_INIT_MJM012402_HPP
--- a/src/mac/msl_replacements/assert.cpp
+++ b/src/mac/msl_replacements/assert.cpp
@@ -0,0 +1,30 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include <cassert>
 #include <cstdio>
 #include <MacTypes.h>
 #include "remote_calls.hpp"
 // this function will be called when an assertion fails.  We redirect the assertion
 //    to DebugStr (MacsBug under Mac OS 1.x-9.x, Console under Mac OS X).
 void __assertion_failed(char const *pszAssertion, char const *pszFile, int nLine)
 {
    using std::snprintf;
    unsigned char strlDebug[sizeof(Str255) + 1];
    char *pszDebug = reinterpret_cast<char *>(&strlDebug[1]);
    strlDebug[0] = snprintf(pszDebug, sizeof(Str255), "assertion failed: \"%s\", %s, line %d", pszAssertion, pszFile, nLine);
    boost::threads::mac::dt_remote_call(DebugStr, static_cast<ConstStringPtr>(strlDebug));
 }
--- a/src/mac/msl_replacements/console_io.cpp
+++ b/src/mac/msl_replacements/console_io.cpp
@@ -0,0 +1,134 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 //
 // includes
 //
 #include <abort_exit.h>
 #include <console.h>
 #include <console_io.h>
 #include <misc_io.h>
 #include <SIOUX.h>
 #include "remote_calls.hpp"
 //
 // using declarations
 //
 using std::__file_handle;
 using std::__idle_proc;
 using std::__io_error;
 using std::__no_io_error;
 using std::size_t;
 using boost::threads::mac::st_remote_call;
 //
 // prototypes
 //
 static bool check_console();
 static int do_read_console(__file_handle ulHandle, unsigned char *pBuffer, size_t *pCount, __idle_proc pfnIdleProc);
 static int do_write_console(__file_handle ulHandle, unsigned char *pBuffer, size_t *pCount, __idle_proc pfnIdleProc);
 //
 // MSL function replacements
 //
 // these two functions are called by cin and cout, respectively, as well as by (all?)
 //    other functions in MSL that do console I/O.  All that they do is as the remote
 //    call manager to ensure that their guts are called at system task time.
 int __read_console(__file_handle handle, unsigned char * buffer, size_t * count, __idle_proc idle_proc)
 {
    return(st_remote_call(do_read_console, handle, buffer, count, idle_proc));
 }
 int __write_console(__file_handle handle, unsigned char * buffer, size_t * count, __idle_proc idle_proc)
 {
    return(st_remote_call(do_write_console, handle, buffer, count, idle_proc));
 }
 //
 // implementations
 //
 static bool check_console()
 {
    static bool s_bHaveConsole(false);
    static bool s_bWontHaveConsole(false);
    if(s_bHaveConsole)
    {
        return(true);
    }
    if(s_bWontHaveConsole == false)
    {
        __stdio_atexit();
        if(InstallConsole(0) != 0)
        {
            s_bWontHaveConsole = true;
            return(false);
        }
        __console_exit = RemoveConsole;
        s_bHaveConsole = true;
        return(true);
    }
    return(false);
 }
 int do_read_console(__file_handle /*ulHandle*/, unsigned char *pBuffer, size_t *pCount, __idle_proc /*pfnIdleProc*/)
 {
    assert(pCount != NULL);
    assert(pBuffer != NULL || *pCount == 0UL);
    if(check_console() == false)
    {
        return(__io_error);
    }
    std::fflush(stdout);
    long lCount = ReadCharsFromConsole(reinterpret_cast<char *>(pBuffer), static_cast<long>(*pCount));
    *pCount = static_cast<size_t>(lCount);
    if(lCount == -1L)
    {
        return(__io_error);
    }
    return(__no_io_error);
 }
 int do_write_console(__file_handle /*ulHandle*/, unsigned char *pBuffer, size_t *pCount, __idle_proc /*pfnIdleProc*/)
 {
    if(check_console() == false)
    {
        return(__io_error);
    }
    long lCount = WriteCharsToConsole(reinterpret_cast<char *>(pBuffer), static_cast<long>(*pCount));
    *pCount = static_cast<size_t>(lCount);
    if(lCount == -1L)
    {
        return(__io_error);
    }
    return(__no_io_error);
 }
--- a/src/mac/msl_replacements/malloc.cpp
+++ b/src/mac/msl_replacements/malloc.cpp
@@ -0,0 +1,58 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 //
 // includes
 //
 #include <cstdlib>
 #include <Multiprocessing.h>
 //
 // using declarations
 //
 using std::size_t;
 extern "C" {
 //
 // prototypes
 //
 void *malloc(size_t ulSize);
 void free(void *pBlock);
 }
 //
 // MSL function replacements
 //
 // all allocation/deallocation currently goes through MPAllocateAligned/MPFree.  This
 //    solution is sub-optimal at best, but will have to do for now.
 void *malloc(size_t ulSize)
 {
    static bool bIgnored = MPLibraryIsLoaded();
    return(MPAllocateAligned(ulSize, kMPAllocateDefaultAligned, 0UL));
 }
 void free(void *pBlock)
 {
    if(pBlock == NULL) return;
    MPFree(pBlock);
 }
--- a/src/mac/msl_replacements/news_and_deletes.cpp
+++ b/src/mac/msl_replacements/news_and_deletes.cpp
@@ -0,0 +1,105 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 //
 // includes
 //
 #include <new>
 #include <Multiprocessing.h>
 //
 // using declarations
 //
 using std::size_t;
 using std::bad_alloc;
 using std::nothrow_t;
 using std::nothrow;
 //
 // local utility functions
 //
 // all allocation/deallocation currently goes through MPAllocateAligned/MPFree.  This
 //    solution is sub-optimal at best, but will have to do for now.
 inline static void *allocate(size_t ulSize, const nothrow_t &)
 {
    static bool bIgnored = MPLibraryIsLoaded();
    return(MPAllocateAligned(ulSize, kMPAllocateDefaultAligned, 0UL));
 }
 inline static void *allocate(size_t ulSize)
 {
    void *pBlock = allocate(ulSize, nothrow);
    if(pBlock == NULL)
        throw(bad_alloc());
    return(pBlock);
 }
 inline static void deallocate(void *pBlock)
 {
    if(pBlock == NULL) return;
    MPFree(pBlock);
 }
 //
 // global operators
 //
 void *operator new(size_t ulSize)
 {
    return(allocate(ulSize));
 }
 void *operator new[](size_t ulSize)
 {
    return(allocate(ulSize));
 }
 void *operator new(size_t ulSize, const nothrow_t &rNoThrow)
 {
    return(allocate(ulSize, rNoThrow));
 }
 void *operator new[](size_t ulSize, const nothrow_t &rNoThrow)
 {
    return(allocate(ulSize, rNoThrow));
 }
 void operator delete(void *pBlock)
 {
    deallocate(pBlock);
 }
 void operator delete[](void *pBlock)
 {
    deallocate(pBlock);
 }
 void operator delete(void *pBlock, const nothrow_t &)
 {
    deallocate(pBlock);
 }
 void operator delete[](void *pBlock, const nothrow_t &)
 {
    deallocate(pBlock);
 }
--- a/src/mac/msl_replacements/time.cpp
+++ b/src/mac/msl_replacements/time.cpp
@@ -0,0 +1,156 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include <cassert>
 // we include timesize.mac.h to get whether or not __TIMESIZE_DOUBLE__ is
 //  defined.  This is not safe, given that __TIMESIZE_DOUBLE__ affects MSL
 //  at MSL's compile time, not ours, so be forgiving if you have changed it
 //  since you have built MSL.
 #include <timesize.mac.h>
 #include <time.h>
 #include <boost/thread/detail/force_cast.hpp>
 #include <boost/thread/xtime.hpp>
 #include "execution_context.hpp"
 #include <DriverServices.h>
 extern "C"
 {
    clock_t __get_clock();
    time_t __get_time();
    int __to_gm_time(time_t *pTime);
    int __is_dst();
 }
 static inline uint64_t get_nanoseconds()
 {
    using boost::detail::thread::force_cast;
    return(force_cast<uint64_t>(AbsoluteToNanoseconds(UpTime())));
 }
 #ifdef __TIMESIZE_DOUBLE__
 // return number of microseconds since startup as a double
 clock_t __get_clock()
 {
    static const double k_dNanosecondsPerMicrosecond(1000.0);
    return(get_nanoseconds() / k_dNanosecondsPerMicrosecond);
 }
 #else
 // return number of ticks (60th of a second) since startup as a long
 clock_t __get_clock()
 {
    static const uint64_t k_ullTicksPerSecond(60ULL);
    static const uint64_t k_ullNanosecondsPerSecond(1000ULL * 1000ULL * 1000ULL);
    static const uint64_t k_ullNanosecondsPerTick(k_ullNanosecondsPerSecond / k_ullTicksPerSecond);
    return(get_nanoseconds() / k_ullNanosecondsPerTick);
 }
 #endif
 // return number of seconds elapsed since Jan 1, 1970
 time_t __get_time()
 {
    boost::xtime sTime;
    int nType = boost::xtime_get(&sTime, boost::TIME_UTC);
    assert(nType == boost::TIME_UTC);
    return(static_cast<time_t>(sTime.sec));
 }
 static inline MachineLocation &read_location()
 {
    static MachineLocation s_sLocation;
    assert(boost::threads::mac::at_st());
    ReadLocation(&s_sLocation);
    return(s_sLocation);
 }
 static inline MachineLocation &get_location()
 {
    static MachineLocation &s_rLocation(read_location());
    return(s_rLocation);
 }
 // force the machine location to be cached at static initlialization
 static MachineLocation &g_rIgnored(get_location());
 static inline long calculate_delta()
 {
    MachineLocation &rLocation(get_location());
 // gmtDelta is a 24-bit, signed integer.  We need to strip out the lower 24 bits,
 //  then sign-extend what we have.
    long lDelta = rLocation.u.gmtDelta & 0x00ffffffL;
    if((lDelta & 0x00800000L) != 0L)
    {
        lDelta |= 0xFF000000;
    }
    return(lDelta);
 }
 static inline bool check_if_location_is_broken()
 {
    MachineLocation &rLocation(get_location());
    if(rLocation.latitude == 0 && rLocation.longitude == 0 && rLocation.u.gmtDelta == 0)
        return(true);
    return(false);
 }
 static inline bool location_is_broken()
 {
    static bool s_bLocationIsBroken(check_if_location_is_broken());
    return(s_bLocationIsBroken);
 }
 // translate time to GMT
 int __to_gm_time(time_t *pTime)
 {
    if(location_is_broken())
    {
        return(0);
    }
    static long s_lDelta(calculate_delta());
    *pTime -= s_lDelta;
    return(1);
 }
 static inline bool is_daylight_savings_time()
 {
    MachineLocation &rLocation(get_location());
    return(rLocation.u.dlsDelta != 0);
 }
 // check if we're in daylight savings time
 int __is_dst()
 {
    if(location_is_broken())
    {
        return(-1);
    }
    static bool bIsDaylightSavingsTime(is_daylight_savings_time());
    return(static_cast<int>(bIsDaylightSavingsTime));
 }
--- a/src/mac/os.cpp
+++ b/src/mac/os.cpp
@@ -0,0 +1,63 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "os.hpp"
 #include <cassert>
 #include <Gestalt.h>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace os {
 // read the OS version from Gestalt
 static inline long get_version()
 {
    long lVersion;
    OSErr nErr = Gestalt(gestaltSystemVersion, &lVersion);
    assert(nErr == noErr);
    return(lVersion);
 }
 // check if we're running under Mac OS X and cache that information
 bool x()
 {
    static bool bX = (version() >= 0x1000);
    return(bX);
 }
 // read the OS version and cache it
 long version()
 {
    static long lVersion = get_version();
    return(lVersion);
 }
 } // namespace os
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/os.hpp
+++ b/src/mac/os.hpp
@@ -0,0 +1,43 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_OS_MJM012402_HPP
 #define BOOST_OS_MJM012402_HPP
 namespace boost {
 namespace threads {
 namespace mac {
 namespace os {
 // functions to determine the OS environment.  With namespaces, you get a cute call:
 //    mac::os::x
 bool x();
 long version();
 } // namespace os
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_OS_MJM012402_HPP
--- a/src/mac/ot_context.cpp
+++ b/src/mac/ot_context.cpp
@@ -0,0 +1,52 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "ot_context.hpp"
 #include "execution_context.hpp"
 #include <cassert>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 ot_context::ot_context()
 {
    assert(at_st());
    OSStatus lStatus = InitOpenTransportInContext(0UL, &m_pContext);
 // TODO - throw on error
    assert(lStatus == noErr);
 }
 ot_context::~ot_context()
 {
    CloseOpenTransportInContext(m_pContext);
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/ot_context.hpp
+++ b/src/mac/ot_context.hpp
@@ -0,0 +1,64 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_OT_CONTEXT_MJM012402_HPP
 #define BOOST_OT_CONTEXT_MJM012402_HPP
 #include <OpenTransport.h>
 #include <boost/utility.hpp>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 // class ot_context is intended to be used only as a singleton.  All that this class
 //    does is ask OpenTransport to create him an OTClientContextPtr, and then doles
 //    this out to anyone who wants it.  ot_context should only be instantiated at
 //    system task time.
 class ot_context: private noncopyable
 {
  protected:
    ot_context();
    ~ot_context();
  public:
    OTClientContextPtr get_context();
  private:
    OTClientContextPtr m_pContext;
 };
 inline OTClientContextPtr ot_context::get_context()
    {    return(m_pContext);    }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_OT_CONTEXT_MJM012402_HPP
--- a/src/mac/package.hpp
+++ b/src/mac/package.hpp
@@ -0,0 +1,82 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_PACKAGE_MJM012402_HPP
 #define BOOST_PACKAGE_MJM012402_HPP
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 class base_package: private noncopyable
 {
  public:
    virtual void accept() = 0;
 };
 template<class R>
 class package: public base_package
 {
  public:
    inline package(function<R> &rFunctor):
        m_rFunctor(rFunctor)
        {    /* no-op */                }
    inline ~package()
        {    /* no-op */                }
    virtual void accept()
        {    m_oR = m_rFunctor();    }
    inline R return_value()
        {    return(m_oR);            }
  private:
    function<R> &m_rFunctor;
    R m_oR;
 };
 template<>
 class package<void>: public base_package
 {
  public:
    inline package(function<void> &rFunctor):
        m_rFunctor(rFunctor)
        {    /* no-op */                }
    inline ~package()
        {    /* no-op */                }
    virtual void accept()
        {    m_rFunctor();            }
    inline void return_value()
        {    return;                    }
  private:
    function<void> &m_rFunctor;
 };
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_PACKAGE_MJM012402_HPP
--- a/src/mac/periodical.hpp
+++ b/src/mac/periodical.hpp
@@ -0,0 +1,103 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_PERIODICAL_MJM012402_HPP
 #define BOOST_PERIODICAL_MJM012402_HPP
 #include <boost/function.hpp>
 #include <boost/utility.hpp>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 // class periodical inherits from its template parameter, which should follow the
 //    pattern set by classes dt_scheduler and st_scheduler.  periodical knows how to
 //    call a boost::function, where the xx_scheduler classes only know to to call a
 //    member periodically.
 template<class Scheduler>
 class periodical: private noncopyable, private Scheduler
 {
  public:
    periodical(function<void> &rFunction);
    ~periodical();
  public:
    void start();
    void stop();
  protected:
    virtual void periodic_function();
  private:
    function<void> m_oFunction;
 };
 template<class Scheduler>
 periodical<Scheduler>::periodical(function<void> &rFunction):
    m_oFunction(rFunction)
 {
 // no-op
 }
 template<class Scheduler>
 periodical<Scheduler>::~periodical()
 {
    stop();
 }
 template<class Scheduler>
 void periodical<Scheduler>::start()
 {
    start_polling();
 }
 template<class Scheduler>
 void periodical<Scheduler>::stop()
 {
    stop_polling();
 }
 template<class Scheduler>
 inline void periodical<Scheduler>::periodic_function()
 {
    try
    {
        m_oFunction();
    }
    catch(...)
    {
    }
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_PERIODICAL_MJM012402_HPP
--- a/src/mac/prefix.hpp
+++ b/src/mac/prefix.hpp
@@ -0,0 +1,15 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #define NDEBUG
 #define TARGET_CARBON    1
--- a/src/mac/remote_call_manager.cpp
+++ b/src/mac/remote_call_manager.cpp
@@ -0,0 +1,54 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "remote_call_manager.hpp"
 #include <boost/bind.hpp>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 using detail::delivery_man;
 remote_call_manager::remote_call_manager():
    m_oDTDeliveryMan(),
    m_oSTDeliveryMan(),
    m_oDTFunction(bind(&delivery_man::accept_deliveries, &m_oDTDeliveryMan)),
    m_oSTFunction(bind(&delivery_man::accept_deliveries, &m_oSTDeliveryMan)),
    m_oDTPeriodical(m_oDTFunction),
    m_oSTPeriodical(m_oSTFunction)
 {
    m_oDTPeriodical.start();
    m_oSTPeriodical.start();
 }
 remote_call_manager::~remote_call_manager()
 {
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/remote_call_manager.hpp
+++ b/src/mac/remote_call_manager.hpp
@@ -0,0 +1,108 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP
 #define BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP
 #include <boost/utility.hpp>
 #include "delivery_man.hpp"
 #include "dt_scheduler.hpp"
 #include "periodical.hpp"
 #include "execution_context.hpp"
 #include "st_scheduler.hpp"
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 // class remote_call_manager is used by the remote call functions (dt_remote_call and
 //  st_remote_call) to execute functions in non-MP contexts.
 class remote_call_manager: private noncopyable
 {
  protected:
    remote_call_manager();
    ~remote_call_manager();
  public:
    template<class R>
    R execute_at_dt(function<R> &rFunctor);
    template<class R>
    R execute_at_st(function<R> &rFunctor);
  private:
    template<class R>
    static R execute_now(function<R> &rFunctor);
  private:
    delivery_man m_oDTDeliveryMan;
    delivery_man m_oSTDeliveryMan;
    function<void> m_oDTFunction;
    function<void> m_oSTFunction;
    periodical<dt_scheduler> m_oDTPeriodical;
    periodical<st_scheduler> m_oSTPeriodical;
 };
 template<class R>
 /*static*/ inline R remote_call_manager::execute_now(function<R> &rFunctor)
 {
    return(rFunctor());
 }
 template<>
 /*static*/ inline void remote_call_manager::execute_now<void>(function<void> &rFunctor)
 {
    rFunctor();
 }
 template<class R>
 inline R remote_call_manager::execute_at_dt(function<R> &rFunctor)
 {
    if(at_mp())
    {
        return(m_oDTDeliveryMan.deliver(rFunctor));
    }
    return(execute_now(rFunctor));
 }
 template<class R>
 inline R remote_call_manager::execute_at_st(function<R> &rFunctor)
 {
    if(at_mp())
    {
        return(m_oSTDeliveryMan.deliver(rFunctor));
    }
    assert(at_st());
    return(execute_now(rFunctor));
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP
--- a/src/mac/remote_calls.hpp
+++ b/src/mac/remote_calls.hpp
@@ -0,0 +1,163 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_REMOTE_CALLS_MJM012402_HPP
 #define BOOST_REMOTE_CALLS_MJM012402_HPP
 #include <boost/bind.hpp>
 #include "remote_call_manager.hpp"
 #include <boost/thread/detail/singleton.hpp>
 // this file contains macros to generate functions with the signatures:
 //  ReturnType st_remote_call([pascal] ReturnType (*pfnFunction)(
 //                              [Argument1Type[, Argument2Type[...]]])
 //                            [, Argument1Type oArgument1[, Argument2Type oArgument2[...]]])
 // and
 //  ReturnType dt_remote_call([pascal] ReturnType (*pfnFunction)(
 //                              [Argument1Type[, Argument2Type[...]]])
 //                            [, Argument1Type oArgument1[, Argument2Type oArgument2[...]]])
 // in other words, identical to the function pointer versions of boost::bind, but
 //  with the return type returned.  The purpose of these functions is to be able to
 //  request that a function be called at system task time or deferred task time, then
 //  sleep until it is called, and finally get back its return value.
 #define BOOST_REMOTE_CALL_CLASS_LIST_0
 #define BOOST_REMOTE_CALL_CLASS_LIST_1 BOOST_REMOTE_CALL_CLASS_LIST_0, class A1
 #define BOOST_REMOTE_CALL_CLASS_LIST_2 BOOST_REMOTE_CALL_CLASS_LIST_1, class A2
 #define BOOST_REMOTE_CALL_CLASS_LIST_3 BOOST_REMOTE_CALL_CLASS_LIST_2, class A3
 #define BOOST_REMOTE_CALL_CLASS_LIST_4 BOOST_REMOTE_CALL_CLASS_LIST_3, class A4
 #define BOOST_REMOTE_CALL_CLASS_LIST_5 BOOST_REMOTE_CALL_CLASS_LIST_4, class A5
 #define BOOST_REMOTE_CALL_CLASS_LIST_6 BOOST_REMOTE_CALL_CLASS_LIST_5, class A6
 #define BOOST_REMOTE_CALL_CLASS_LIST_7 BOOST_REMOTE_CALL_CLASS_LIST_6, class A7
 #define BOOST_REMOTE_CALL_CLASS_LIST_8 BOOST_REMOTE_CALL_CLASS_LIST_7, class A8
 #define BOOST_REMOTE_CALL_CLASS_LIST_9 BOOST_REMOTE_CALL_CLASS_LIST_8, class A9
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_0
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_1 BOOST_REMOTE_CALL_ARGUMENT_LIST_0  A1 oA1
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_2 BOOST_REMOTE_CALL_ARGUMENT_LIST_1, A2 oA2
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_3 BOOST_REMOTE_CALL_ARGUMENT_LIST_2, A3 oA3
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_4 BOOST_REMOTE_CALL_ARGUMENT_LIST_3, A4 oA4
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_5 BOOST_REMOTE_CALL_ARGUMENT_LIST_4, A5 oA5
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_6 BOOST_REMOTE_CALL_ARGUMENT_LIST_5, A6 oA6
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_7 BOOST_REMOTE_CALL_ARGUMENT_LIST_6, A7 oA7
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_8 BOOST_REMOTE_CALL_ARGUMENT_LIST_7, A8 oA8
 #define BOOST_REMOTE_CALL_ARGUMENT_LIST_9 BOOST_REMOTE_CALL_ARGUMENT_LIST_8, A9 oA9
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_0
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_1 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_0, oA1
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_2 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_1, oA2
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_3 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_2, oA3
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_4 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_3, oA4
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_5 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_4, oA5
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_6 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_5, oA6
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_7 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_6, oA7
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_8 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_7, oA8
 #define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_9 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_8, oA9
 #define BOOST_REMOTE_CALL_COMMA_0
 #define BOOST_REMOTE_CALL_COMMA_1 ,
 #define BOOST_REMOTE_CALL_COMMA_2 ,
 #define BOOST_REMOTE_CALL_COMMA_3 ,
 #define BOOST_REMOTE_CALL_COMMA_4 ,
 #define BOOST_REMOTE_CALL_COMMA_5 ,
 #define BOOST_REMOTE_CALL_COMMA_6 ,
 #define BOOST_REMOTE_CALL_COMMA_7 ,
 #define BOOST_REMOTE_CALL_COMMA_8 ,
 #define BOOST_REMOTE_CALL_COMMA_9 ,
 // this is the macro that ties it all together.  From here, we generate all forms of
 //  dt_remote_call and st_remote_call.
 #define BOOST_REMOTE_CALL(context, stack, n)                                        \
 template<class R BOOST_REMOTE_CALL_CLASS_LIST_ ## n>                                \
 inline R context ## _remote_call(stack R (*pfnF)(                                   \
                                      BOOST_REMOTE_CALL_ARGUMENT_LIST_ ## n)        \
                                      BOOST_REMOTE_CALL_COMMA_ ## n                 \
                                  BOOST_REMOTE_CALL_ARGUMENT_LIST_ ## n)            \
 {                                                                                   \
    using ::boost::detail::thread::singleton;                                       \
    using detail::remote_call_manager;                                              \
    function<R> oFunc(bind(pfnF BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_ ## n));   \
    remote_call_manager &rManager(singleton<remote_call_manager>::instance());      \
    return(rManager.execute_at_ ## context(oFunc));                                 \
 }
 namespace boost {
 namespace threads {
 namespace mac {
 BOOST_REMOTE_CALL(st, , 0)
 BOOST_REMOTE_CALL(st, , 1)
 BOOST_REMOTE_CALL(st, , 2)
 BOOST_REMOTE_CALL(st, , 3)
 BOOST_REMOTE_CALL(st, , 4)
 BOOST_REMOTE_CALL(st, , 5)
 BOOST_REMOTE_CALL(st, , 6)
 BOOST_REMOTE_CALL(st, , 7)
 BOOST_REMOTE_CALL(st, , 8)
 BOOST_REMOTE_CALL(st, , 9)
 BOOST_REMOTE_CALL(dt, , 0)
 BOOST_REMOTE_CALL(dt, , 1)
 BOOST_REMOTE_CALL(dt, , 2)
 BOOST_REMOTE_CALL(dt, , 3)
 BOOST_REMOTE_CALL(dt, , 4)
 BOOST_REMOTE_CALL(dt, , 5)
 BOOST_REMOTE_CALL(dt, , 6)
 BOOST_REMOTE_CALL(dt, , 7)
 BOOST_REMOTE_CALL(dt, , 8)
 BOOST_REMOTE_CALL(dt, , 9)
 BOOST_REMOTE_CALL(st, pascal, 0)
 BOOST_REMOTE_CALL(st, pascal, 1)
 BOOST_REMOTE_CALL(st, pascal, 2)
 BOOST_REMOTE_CALL(st, pascal, 3)
 BOOST_REMOTE_CALL(st, pascal, 4)
 BOOST_REMOTE_CALL(st, pascal, 5)
 BOOST_REMOTE_CALL(st, pascal, 6)
 BOOST_REMOTE_CALL(st, pascal, 7)
 BOOST_REMOTE_CALL(st, pascal, 8)
 BOOST_REMOTE_CALL(st, pascal, 9)
 BOOST_REMOTE_CALL(dt, pascal, 0)
 BOOST_REMOTE_CALL(dt, pascal, 1)
 BOOST_REMOTE_CALL(dt, pascal, 2)
 BOOST_REMOTE_CALL(dt, pascal, 3)
 BOOST_REMOTE_CALL(dt, pascal, 4)
 BOOST_REMOTE_CALL(dt, pascal, 5)
 BOOST_REMOTE_CALL(dt, pascal, 6)
 BOOST_REMOTE_CALL(dt, pascal, 7)
 BOOST_REMOTE_CALL(dt, pascal, 8)
 BOOST_REMOTE_CALL(dt, pascal, 9)
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_REMOTE_CALLS_MJM012402_HPP
--- a/src/mac/safe.cpp
+++ b/src/mac/safe.cpp
@@ -0,0 +1,216 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include <DriverServices.h>
 #include <Events.h>
 #include <Multiprocessing.h>
 #include <Threads.h>
 #include <boost/bind.hpp>
 #include <boost/function.hpp>
 #include <boost/thread/detail/force_cast.hpp>
 #include <limits>
 #include "execution_context.hpp"
 using boost::detail::thread::force_cast;
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 static OSStatus safe_wait(function<OSStatus, Duration> &rFunction, Duration lDuration);
 // we call WNE to allow tasks that own the resource the blue is waiting on system
 //    task time, in case they are blocked on an ST remote call (or a memory allocation
 //    for that matter).
 static void idle()
 {
    if(at_st())
    {
        EventRecord sEvent;
        bool bEvent = WaitNextEvent(0U, &sEvent, 0UL, NULL);
    }
 }
 OSStatus safe_wait_on_semaphore(MPSemaphoreID pSemaphoreID, Duration lDuration)
 {
    function<OSStatus, Duration> oWaitOnSemaphore;
    oWaitOnSemaphore = bind(MPWaitOnSemaphore, pSemaphoreID, _1);
    return(safe_wait(oWaitOnSemaphore, lDuration));
 }
 OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Duration lDuration, MPCriticalRegionID pCriticalRegionCriticalRegionID/* = kInvalidID*/)
 {
    if(pCriticalRegionCriticalRegionID != kInvalidID)
    {
        if(at_mp())
        {
        // enter the critical region's critical region
            OSStatus lStatus = noErr;
            AbsoluteTime sExpiration;
            if(lDuration != kDurationImmediate && lDuration != kDurationForever)
            {
                sExpiration = AddDurationToAbsolute(lDuration, UpTime());
            }            
            lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, lDuration);
            assert(lStatus == noErr || lStatus == kMPTimeoutErr);
            if(lStatus == noErr)
            {
            // calculate a new duration
                if(lDuration != kDurationImmediate && lDuration != kDurationForever)
                {
                // check if we have any time left
                    AbsoluteTime sUpTime(UpTime());
                    if(force_cast<uint64_t>(sExpiration) > force_cast<uint64_t>(sUpTime))
                    {
                    // reset our duration to our remaining time
                        lDuration = AbsoluteDeltaToDuration(sExpiration, sUpTime);
                    }
                    else
                    {
                    // no time left
                        lDuration = kDurationImmediate;
                    }
                }            
            // if we entered the critical region, exit it again
                lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
                assert(lStatus == noErr);
            }
            else
            {
            // otherwise, give up
                return(lStatus);
            }
        }
        else
        {
        // if we're at system task time, try to enter the critical region's critical
        //    region until we succeed.  MP tasks will block on this until we let it go.
            OSStatus lStatus;
            do
            {
                lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, kDurationImmediate);
            } while(lStatus == kMPTimeoutErr);
            assert(lStatus == noErr);
        }
    }
 // try to enter the critical region
    function<OSStatus, Duration> oEnterCriticalRegion;
    oEnterCriticalRegion = bind(MPEnterCriticalRegion, pCriticalRegionID, _1);
    OSStatus lStatus = safe_wait(oEnterCriticalRegion, lDuration);
 // if we entered the critical region's critical region to get the critical region,
 //    exit the critical region's critical region.
    if(pCriticalRegionCriticalRegionID != kInvalidID && at_mp() == false)
    {
        lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
        assert(lStatus == noErr);
    }
    return(lStatus);
 }
 OSStatus safe_wait_on_queue(MPQueueID pQueueID, void **pParam1, void **pParam2, void **pParam3, Duration lDuration)
 {
    function<OSStatus, Duration> oWaitOnQueue;
    oWaitOnQueue = bind(MPWaitOnQueue, pQueueID, pParam1, pParam2, pParam3, _1);
    return(safe_wait(oWaitOnQueue, lDuration));
 }
 OSStatus safe_delay_until(AbsoluteTime *pWakeUpTime)
 {
    if(execution_context() == k_eExecutionContextMPTask)
    {
        return(MPDelayUntil(pWakeUpTime));
    }
    else
    {
        uint64_t ullWakeUpTime = force_cast<uint64_t>(*pWakeUpTime);
        while(force_cast<uint64_t>(UpTime()) < ullWakeUpTime)
        {
            idle();
        }
        return(noErr);
    }
 }
 OSStatus safe_wait(function<OSStatus, Duration> &rFunction, Duration lDuration)
 {
    if(execution_context() == k_eExecutionContextMPTask)
    {
        return(rFunction(lDuration));
    }
    else
    {
        uint64_t ullExpiration = 0ULL;
    // get the expiration time in UpTime units
        if(lDuration == kDurationForever)
        {
            ullExpiration = ::std::numeric_limits<uint64_t>::max();
        }
        else if(lDuration == kDurationImmediate)
        {
            ullExpiration = force_cast<uint64_t>(UpTime());
        }
        else
        {
            AbsoluteTime sExpiration = AddDurationToAbsolute(lDuration, UpTime());
            ullExpiration = force_cast<uint64_t>(sExpiration);
        }
        OSStatus lStatus;
        bool bExpired = false;
        do
        {
            lStatus = rFunction(kDurationImmediate);
 // mm - "if" #if 0'd out to allow task time to threads blocked on I/O
 #if 0
            if(lStatus == kMPTimeoutErr)
 #endif
            {
                idle();
            }
            if(lDuration != kDurationForever)
            {
                bExpired = (force_cast<uint64_t>(UpTime()) < ullExpiration);
            }
        } while(lStatus == kMPTimeoutErr && bExpired == false);
        return(lStatus);
    }
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/safe.hpp
+++ b/src/mac/safe.hpp
@@ -0,0 +1,47 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_SAFE_MJM012402_HPP
 #define BOOST_SAFE_MJM012402_HPP
 #include <Multiprocessing.h>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 // these functions are used to wain in an execution context-independent manor.  All of these
 //  functions are both MP- and ST-safe.
 OSStatus safe_wait_on_semaphore(MPSemaphoreID pSemaphoreID, Duration lDuration);
 OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Duration lDuration, MPCriticalRegionID pCriticalRegionCriticalRegionID = kInvalidID);
 OSStatus safe_wait_on_queue(MPQueueID pQueueID, void **pParam1, void **pParam2, void **pParam3, Duration lDuration);
 OSStatus safe_delay_until(AbsoluteTime *pWakeUpTime);
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_SAFE_MJM012402_HPP
--- a/src/mac/scoped_critical_region.cpp
+++ b/src/mac/scoped_critical_region.cpp
@@ -0,0 +1,53 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "scoped_critical_region.hpp"
 #include "init.hpp"
 #include <cassert>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 scoped_critical_region::scoped_critical_region():
    m_pCriticalRegionID(kInvalidID)
 {
    static bool bIgnored = thread_init();
    OSStatus lStatus = MPCreateCriticalRegion(&m_pCriticalRegionID);
    if(lStatus != noErr || m_pCriticalRegionID == kInvalidID)
        throw(thread_resource_error());
 }
 scoped_critical_region::~scoped_critical_region()
 {
    OSStatus lStatus = MPDeleteCriticalRegion(m_pCriticalRegionID);
    assert(lStatus == noErr);
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/scoped_critical_region.hpp
+++ b/src/mac/scoped_critical_region.hpp
@@ -0,0 +1,69 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP
 #define BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP
 #include <boost/thread/exceptions.hpp>
 #include <Multiprocessing.h>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 // class scoped_critical_region probably needs a new name.  Although the current name
 //    is accurate, it can be read to mean that a critical region is entered for the
 //    current scope.  In reality, a critical region is _created_ for the current scope.
 //    This class is intended as a replacement for MPCriticalRegionID that will
 //    automatically create and dispose of itself.
 class scoped_critical_region
 {
  public:
    scoped_critical_region();
    ~scoped_critical_region();
  public:
    operator const MPCriticalRegionID &() const;
    const MPCriticalRegionID &get() const;
  private:
    MPCriticalRegionID m_pCriticalRegionID;
 };
 // these are inlined for speed.
 inline scoped_critical_region::operator const MPCriticalRegionID &() const
    {    return(m_pCriticalRegionID);    }
 inline const MPCriticalRegionID &scoped_critical_region::get() const
    {    return(m_pCriticalRegionID);    }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP
--- a/src/mac/st_scheduler.cpp
+++ b/src/mac/st_scheduler.cpp
@@ -0,0 +1,91 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "st_scheduler.hpp"
 #include <cassert>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 #if TARGET_CARBON
 st_scheduler::st_scheduler():
    m_uppTask(NULL),
    m_pTimer(NULL)
 {
    m_uppTask = NewEventLoopTimerUPP(task_entry);
 // TODO - throw on error
    assert(m_uppTask != NULL);
 }
 st_scheduler::~st_scheduler()
 {
    DisposeEventLoopTimerUPP(m_uppTask);
    m_uppTask = NULL;
 }
 void st_scheduler::start_polling()
 {
    assert(m_pTimer == NULL);
    OSStatus lStatus = InstallEventLoopTimer(GetMainEventLoop(),
                                                0 * kEventDurationSecond,
                                                kEventDurationMillisecond,
                                                m_uppTask,
                                                this,
                                                &m_pTimer);
 // TODO - throw on error
    assert(lStatus == noErr);
 }
 void st_scheduler::stop_polling()
 {
    assert(m_pTimer != NULL);
    OSStatus lStatus = RemoveEventLoopTimer(m_pTimer);
    assert(lStatus == noErr);
    m_pTimer = NULL;
 }
 /*static*/ pascal void st_scheduler::task_entry(EventLoopTimerRef /*pTimer*/, void *pRefCon)
 {
    st_scheduler *pThis = reinterpret_cast<st_scheduler *>(pRefCon);
    assert(pThis != NULL);
    pThis->task();
 }
 void st_scheduler::task()
 {
    periodic_function();
 }
 #else
 #    error st_scheduler unimplemented!
 #endif
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/st_scheduler.hpp
+++ b/src/mac/st_scheduler.hpp
@@ -0,0 +1,73 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_ST_SCHEDULER_MJM012402_HPP
 #define BOOST_ST_SCHEDULER_MJM012402_HPP
 #include <CarbonEvents.h>
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 // class st_scheduler calls its pure-virtual periodic_function method periodically at
 //  system task time.  This is generally 40Hz under Mac OS 9.
 class st_scheduler
 {
  public:
    st_scheduler();
    virtual ~st_scheduler();
  protected:
    void start_polling();
    void stop_polling();
  private:
    virtual void periodic_function() = 0;
 #if TARGET_CARBON
 // use event loop timers under Carbon
  private:
    static pascal void task_entry(EventLoopTimerRef pTimer, void *pRefCon);
    void task();
  private:
    EventLoopTimerUPP m_uppTask;
    EventLoopTimerRef m_pTimer;
 #else
 // this can be implemented using OT system tasks.  This would be mostly a copy-and-
 //  paste of the dt_scheduler code, replacing DeferredTask with SystemTask and DT
 //  with ST.
 #   error st_scheduler unimplemented!
 #endif
 };
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_ST_SCHEDULER_MJM012402_HPP
--- a/src/mac/thread_cleanup.cpp
+++ b/src/mac/thread_cleanup.cpp
@@ -0,0 +1,62 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #include "thread_cleanup.hpp"
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 namespace {
 TaskStorageIndex g_ulIndex(0UL);
 } // anonymous namespace
 void do_thread_startup()
 {
    if(g_ulIndex == 0UL)
    {
        OSStatus lStatus = MPAllocateTaskStorageIndex(&g_ulIndex);
        assert(lStatus == noErr);
    }
    set_thread_cleanup_task(NULL);
 }
 void do_thread_cleanup()
 {
    void (*pfnTask)() = MPGetTaskValue(g_ulIndex)
 }
 void set_thread_cleanup_task(void (*pfnTask)())
 {
    lStatus = MPSetTaskValue(g_ulIndex, reinterpret_cast<TaskStorageValue>(pfnTask));
    assert(lStatus == noErr);
 }
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
--- a/src/mac/thread_cleanup.hpp
+++ b/src/mac/thread_cleanup.hpp
@@ -0,0 +1,42 @@
 // Copyright (C) 2001
 // Mac Murrett
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  Mac Murrett makes no representations
 // about the suitability of this software for any purpose.  It is
 // provided "as is" without express or implied warranty.
 //
 // See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_THREAD_CLEANUP_MJM012402_HPP
 #define BOOST_THREAD_CLEANUP_MJM012402_HPP
 namespace boost {
 namespace threads {
 namespace mac {
 namespace detail {
 void do_thread_startup();
 void do_thread_cleanup();
 void set_thread_cleanup_task();
 } // namespace detail
 } // namespace mac
 } // namespace threads
 } // namespace boost
 #endif // BOOST_THREAD_CLEANUP_MJM012402_HPP
--- a/src/mutex.cpp
+++ b/src/mutex.cpp
@@ -0,0 +1,535 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <boost/limits.hpp>
 #include <stdexcept>
 #include <cassert>
 #include <new>
 #include "timeconv.inl"
 #if defined(BOOST_HAS_WINTHREADS)
 #   include <windows.h>
 #   include <time.h>
 #elif defined(BOOST_HAS_PTHREADS)
 #   include <errno.h>
 #elif defined(BOOST_HAS_MPTASKS)
 #    include <MacErrors.h>
 #    include "mac/init.hpp"
 #    include "mac/safe.hpp"
 #endif
 namespace boost {
 #if defined(BOOST_HAS_WINTHREADS)
 mutex::mutex()
 {
    m_mutex = reinterpret_cast<void*>(new(std::nothrow) CRITICAL_SECTION);
    if (!m_mutex)
        throw thread_resource_error();
    InitializeCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
 }
 mutex::~mutex()
 {
    DeleteCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
    delete reinterpret_cast<LPCRITICAL_SECTION>(m_mutex);
 }
 void mutex::do_lock()
 {
    EnterCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
 }
 void mutex::do_unlock()
 {
    LeaveCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
 }
 void mutex::do_lock(cv_state&)
 {
    do_lock();
 }
 void mutex::do_unlock(cv_state&)
 {
    do_unlock();
 }
 try_mutex::try_mutex()
 {
    m_mutex = reinterpret_cast<void*>(CreateMutex(0, 0, 0));
    if (!m_mutex)
        throw thread_resource_error();
 }
 try_mutex::~try_mutex()
 {
    int res = 0;
    res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 void try_mutex::do_lock()
 {
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
 }
 bool try_mutex::do_trylock()
 {
    unsigned int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), 0);
    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
    return res == WAIT_OBJECT_0;
 }
 void try_mutex::do_unlock()
 {
    int res = 0;
    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 void try_mutex::do_lock(cv_state&)
 {
    do_lock();
 }
 void try_mutex::do_unlock(cv_state&)
 {
    do_unlock();
 }
 timed_mutex::timed_mutex()
 {
    m_mutex = reinterpret_cast<void*>(CreateMutex(0, 0, 0));
    if (!m_mutex)
        throw thread_resource_error();
 }
 timed_mutex::~timed_mutex()
 {
    int res = 0;
    res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 void timed_mutex::do_lock()
 {
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
 }
 bool timed_mutex::do_trylock()
 {
    unsigned int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), 0);
    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
    return res == WAIT_OBJECT_0;
 }
 bool timed_mutex::do_timedlock(const xtime& xt)
 {
    int milliseconds;
    to_duration(xt, milliseconds);
    unsigned int res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
    return res == WAIT_OBJECT_0;
 }
 void timed_mutex::do_unlock()
 {
    int res = 0;
    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 void timed_mutex::do_lock(cv_state&)
 {
    do_lock();
 }
 void timed_mutex::do_unlock(cv_state&)
 {
    do_unlock();
 }
 #elif defined(BOOST_HAS_PTHREADS)
 mutex::mutex()
 {
    int res = 0;
    res = pthread_mutex_init(&m_mutex, 0);
    if (res != 0)
        throw thread_resource_error();
 }
 mutex::~mutex()
 {
    int res = 0;
    res = pthread_mutex_destroy(&m_mutex);
    assert(res == 0);
 }
 void mutex::do_lock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    if (res == EDEADLK) throw lock_error();
    assert(res == 0);
 }
 void mutex::do_unlock()
 {
    int res = 0;
    res = pthread_mutex_unlock(&m_mutex);
    if (res == EPERM) throw lock_error();
    assert(res == 0);
 }
 void mutex::do_lock(cv_state&)
 {
 }
 void mutex::do_unlock(cv_state& state)
 {
    state.pmutex = &m_mutex;
 }
 try_mutex::try_mutex()
 {
    int res = 0;
    res = pthread_mutex_init(&m_mutex, 0);
    if (res != 0)
        throw thread_resource_error();
 }
 try_mutex::~try_mutex()
 {
    int res = 0;
    res = pthread_mutex_destroy(&m_mutex);
    assert(res == 0);
 }
 void try_mutex::do_lock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    if (res == EDEADLK) throw lock_error();
    assert(res == 0);
 }
 bool try_mutex::do_trylock()
 {
    int res = 0;
    res = pthread_mutex_trylock(&m_mutex);
    if (res == EDEADLK) throw lock_error();
    assert(res == 0 || res == EBUSY);
    return res == 0;
 }
 void try_mutex::do_unlock()
 {
    int res = 0;
    res = pthread_mutex_unlock(&m_mutex);
    if (res == EPERM) throw lock_error();
    assert(res == 0);
 }
 void try_mutex::do_lock(cv_state&)
 {
 }
 void try_mutex::do_unlock(cv_state& state)
 {
    state.pmutex = &m_mutex;
 }
 timed_mutex::timed_mutex()
    : m_locked(false)
 {
    int res = 0;
    res = pthread_mutex_init(&m_mutex, 0);
    if (res != 0)
        throw thread_resource_error();
    res = pthread_cond_init(&m_condition, 0);
    if (res != 0)
    {
        pthread_mutex_destroy(&m_mutex);
        throw thread_resource_error();
    }
 }
 timed_mutex::~timed_mutex()
 {
    assert(!m_locked);
    int res = 0;
    res = pthread_mutex_destroy(&m_mutex);
    assert(res == 0);
    res = pthread_cond_destroy(&m_condition);
    assert(res == 0);
 }
 void timed_mutex::do_lock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    while (m_locked)
    {
        res = pthread_cond_wait(&m_condition, &m_mutex);
        assert(res == 0);
    }
    assert(!m_locked);
    m_locked = true;
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 }
 bool timed_mutex::do_trylock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    bool ret = false;
    if (!m_locked)
    {
        m_locked = true;
        ret = true;
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
    return ret;
 }
 bool timed_mutex::do_timedlock(const xtime& xt)
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    timespec ts;
    to_timespec(xt, ts);
    while (m_locked)
    {
        res = pthread_cond_timedwait(&m_condition, &m_mutex, &ts);
        assert(res == 0 || res == ETIMEDOUT);
        if (res == ETIMEDOUT)
            break;
    }
    bool ret = false;
    if (!m_locked)
    {
        m_locked = true;
        ret = true;
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
    return ret;
 }
 void timed_mutex::do_unlock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    assert(m_locked);
    m_locked = false;
    res = pthread_cond_signal(&m_condition);
    assert(res == 0);
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 }
 void timed_mutex::do_lock(cv_state&)
 {
    int res = 0;
    while (m_locked)
    {
        res = pthread_cond_wait(&m_condition, &m_mutex);
        assert(res == 0);
    }
    assert(!m_locked);
    m_locked = true;
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 }
 void timed_mutex::do_unlock(cv_state& state)
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    assert(m_locked);
    m_locked = false;
    res = pthread_cond_signal(&m_condition);
    assert(res == 0);
    state.pmutex = &m_mutex;
 }
 #elif defined(BOOST_HAS_MPTASKS)
 using threads::mac::detail::safe_enter_critical_region;
 mutex::mutex()
 {
 }
 mutex::~mutex()
 {
 }
 void mutex::do_lock()
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
 }
 void mutex::do_unlock()
 {
    OSStatus lStatus = noErr;
    lStatus = MPExitCriticalRegion(m_mutex);
    assert(lStatus == noErr);
 }
 void mutex::do_lock(cv_state& /*state*/)
 {
    do_lock();
 }
 void mutex::do_unlock(cv_state& /*state*/)
 {
    do_unlock();
 }
 try_mutex::try_mutex()
 {
 }
 try_mutex::~try_mutex()
 {
 }
 void try_mutex::do_lock()
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
 }
 bool try_mutex::do_trylock()
 {
    OSStatus lStatus = noErr;
    lStatus = MPEnterCriticalRegion(m_mutex, kDurationImmediate);
    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
    return lStatus == noErr;
 }
 void try_mutex::do_unlock()
 {
    OSStatus lStatus = noErr;
    lStatus = MPExitCriticalRegion(m_mutex);
    assert(lStatus == noErr);
 }
 void try_mutex::do_lock(cv_state& /*state*/)
 {
    do_lock();
 }
 void try_mutex::do_unlock(cv_state& /*state*/)
 {
    do_unlock();
 }
 timed_mutex::timed_mutex()
 {
 }
 timed_mutex::~timed_mutex()
 {
 }
 void timed_mutex::do_lock()
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
 }
 bool timed_mutex::do_trylock()
 {
    OSStatus lStatus = noErr;
    lStatus = MPEnterCriticalRegion(m_mutex, kDurationImmediate);
    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
    return(lStatus == noErr);
 }
 bool timed_mutex::do_timedlock(const xtime& xt)
 {
    int microseconds;
    to_microduration(xt, microseconds);
    Duration lDuration = kDurationMicrosecond * microseconds;
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, lDuration, m_mutex_mutex);
    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
    return(lStatus == noErr);
 }
 void timed_mutex::do_unlock()
 {
    OSStatus lStatus = noErr;
    lStatus = MPExitCriticalRegion(m_mutex);
    assert(lStatus == noErr);
 }
 void timed_mutex::do_lock(cv_state& /*state*/)
 {
    do_lock();
 }
 void timed_mutex::do_unlock(cv_state& /*state*/)
 {
    do_unlock();
 }
 #endif
 } // namespace boost
 // Change Log:
 //   8 Feb 01  WEKEMPF Initial version.
--- a/src/once.cpp
+++ b/src/once.cpp
@@ -0,0 +1,139 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #include <boost/thread/once.hpp>
 #include <cstdio>
 #include <cassert>
 #if defined(BOOST_HAS_WINTHREADS)
 #   include <windows.h>
 #   if defined(BOOST_NO_STRINGSTREAM)
 #       include <strstream>
        class unfreezer
        {
        public:
            unfreezer(std::ostrstream& s) : m_stream(s) {}
            ~unfreezer() { m_stream.freeze(false); }
        private:
            std::ostrstream& m_stream;
        };
 #   else
 #       include <sstream>
 #   endif
 #elif defined(BOOST_HAS_MPTASKS)
 #   include <Multiprocessing.h>
 #endif
 #ifdef BOOST_NO_STDC_NAMESPACE
    namespace std { using ::sprintf; }
 #endif
 #if defined(BOOST_HAS_PTHREADS)
 namespace {
 pthread_key_t key;
 pthread_once_t once = PTHREAD_ONCE_INIT;
 typedef void (*once_callback)();
 }
 extern "C" {
 static void key_init()
 {
    pthread_key_create(&key, 0);
 }
 static void do_once()
 {
    once_callback* cb = reinterpret_cast<once_callback*>(pthread_getspecific(key));
    (**cb)();
 }
 }
 #elif defined(BOOST_HAS_MPTASKS)
 void *remote_call_proxy(void *pData)
 {
    std::pair<void (*)(), boost::once_flag *> &rData(*reinterpret_cast<std::pair<void (*)(), boost::once_flag *> *>(pData));
    if(*rData.second == false)
    {
        rData.first();
        *rData.second = true;
    }
    return(NULL);
 }
 #endif
 namespace boost {
 void call_once(void (*func)(), once_flag& flag)
 {
 #if defined(BOOST_HAS_WINTHREADS)
    once_flag tmp = flag;
    // Memory barrier would be needed here to prevent race conditions on some platforms with
    // partial ordering.
    if (!tmp)
    {
 #if defined(BOOST_NO_STRINGSTREAM)
        std::ostrstream strm;
        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" << std::hex << GetCurrentProcessId() << &flag << std::ends;
        unfreezer unfreeze(strm);
        HANDLE mutex = CreateMutex(NULL, FALSE, strm.str());
 #else
        std::ostringstream strm;
        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" << std::hex << GetCurrentProcessId() << &flag;
        HANDLE mutex = CreateMutex(NULL, FALSE, strm.str().c_str());
 #endif
        assert(mutex != NULL);
        int res = 0;
        res = WaitForSingleObject(mutex, INFINITE);
        assert(res == WAIT_OBJECT_0);
        tmp = flag;
        if (!tmp)
        {
            func();
            tmp = true;
            // Memory barrier would be needed here to prevent race conditions on some platforms
            // with partial ordering.
            flag = tmp;
        }
        res = ReleaseMutex(mutex);
        assert(res);
        res = CloseHandle(mutex);
        assert(res);
    }
 #elif defined(BOOST_HAS_PTHREADS)
    pthread_once(&once, &key_init);
    pthread_setspecific(key, &func);
    pthread_once(&flag, do_once);
 #elif defined(BOOST_HAS_MPTASKS)
    if(flag == false)
    {
    // all we do here is make a remote call to blue, as blue is not reentrant.
        std::pair<void (*)(), once_flag *> sData(func, &flag);
        MPRemoteCall(remote_call_proxy, &sData, kMPOwningProcessRemoteContext);
        assert(flag == true);
    }
 #endif
 }
 }
 // Change Log:
 //   1 Aug 01  WEKEMPF Initial version.
--- a/src/recursive_mutex.cpp
+++ b/src/recursive_mutex.cpp
@@ -0,0 +1,992 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/limits.hpp>
 #include <stdexcept>
 #include <cassert>
 #include "timeconv.inl"
 #if defined(BOOST_HAS_WINTHREADS)
 #   include <windows.h>
 #   include <time.h>
 #elif defined(BOOST_HAS_PTHREADS)
 #   include <errno.h>
 #elif defined(BOOST_HAS_MPTASKS)
 #    include <MacErrors.h>
 #    include "safe.hpp"
 #endif
 namespace boost {
 #if defined(BOOST_HAS_WINTHREADS)
 recursive_mutex::recursive_mutex()
    : m_count(0)
 {
    m_mutex = reinterpret_cast<void*>(new(std::nothrow) CRITICAL_SECTION);
    if (!m_mutex)
        throw thread_resource_error();
    InitializeCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
 }
 recursive_mutex::~recursive_mutex()
 {
    DeleteCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
    delete reinterpret_cast<LPCRITICAL_SECTION>(m_mutex);
 }
 void recursive_mutex::do_lock()
 {
    EnterCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
    if (++m_count > 1)
        LeaveCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
 }
 void recursive_mutex::do_unlock()
 {
    if (--m_count == 0)
        LeaveCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
 }
 void recursive_mutex::do_lock(cv_state& state)
 {
    EnterCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
    m_count = state;
 }
 void recursive_mutex::do_unlock(cv_state& state)
 {
    state = m_count;
    m_count = 0;
    LeaveCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
 }
 recursive_try_mutex::recursive_try_mutex()
    : m_count(0)
 {
    m_mutex = reinterpret_cast<void*>(CreateMutex(0, 0, 0));
    if (!m_mutex)
        throw thread_resource_error();
 }
 recursive_try_mutex::~recursive_try_mutex()
 {
    int res = 0;
    res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 void recursive_try_mutex::do_lock()
 {
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
    if (++m_count > 1)
    {
        res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
        assert(res);
    }
 }
 bool recursive_try_mutex::do_trylock()
 {
    unsigned int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), 0);
    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
    if (res == WAIT_OBJECT_0)
    {
        if (++m_count > 1)
        {
            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
            assert(res);
        }
        return true;
    }
    return false;
 }
 void recursive_try_mutex::do_unlock()
 {
    if (--m_count == 0)
    {
        int res = 0;
        res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
        assert(res);
    }
 }
 void recursive_try_mutex::do_lock(cv_state& state)
 {
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
    m_count = state;
 }
 void recursive_try_mutex::do_unlock(cv_state& state)
 {
    state = m_count;
    m_count = 0;
    int res = 0;
    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 recursive_timed_mutex::recursive_timed_mutex()
    : m_count(0)
 {
    m_mutex = reinterpret_cast<void*>(CreateMutex(0, 0, 0));
    if (!m_mutex)
        throw thread_resource_error();
 }
 recursive_timed_mutex::~recursive_timed_mutex()
 {
    int res = 0;
    res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 void recursive_timed_mutex::do_lock()
 {
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
    if (++m_count > 1)
    {
        res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
        assert(res);
    }
 }
 bool recursive_timed_mutex::do_trylock()
 {
    unsigned int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), 0);
    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
    if (res == WAIT_OBJECT_0)
    {
        if (++m_count > 1)
        {
            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
            assert(res);
        }
        return true;
    }
    return false;
 }
 bool recursive_timed_mutex::do_timedlock(const xtime& xt)
 {
    int milliseconds;
    to_duration(xt, milliseconds);
    unsigned int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
    if (res == WAIT_OBJECT_0)
    {
        if (++m_count > 1)
        {
            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
            assert(res);
        }
        return true;
    }
    return false;
 }
 void recursive_timed_mutex::do_unlock()
 {
    if (--m_count == 0)
    {
        int res = 0;
        res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
        assert(res);
    }
 }
 void recursive_timed_mutex::do_lock(cv_state& state)
 {
    int res = 0;
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), INFINITE);
    assert(res == WAIT_OBJECT_0);
    m_count = state;
 }
 void recursive_timed_mutex::do_unlock(cv_state& state)
 {
    state = m_count;
    m_count = 0;
    int res = 0;
    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
    assert(res);
 }
 #elif defined(BOOST_HAS_PTHREADS)
 recursive_mutex::recursive_mutex()
    : m_count(0)
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    , m_valid_id(false)
 #   endif
 {
    pthread_mutexattr_t attr;
    int res = 0;
    res = pthread_mutexattr_init(&attr);
    assert(res == 0);
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    assert(res == 0);
 #   endif
    res = pthread_mutex_init(&m_mutex, &attr);
    if (res != 0)
        throw thread_resource_error();
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    res = pthread_cond_init(&m_unlocked, 0);
    if (res != 0)
    {
        pthread_mutex_destroy(&m_mutex);
        throw thread_resource_error();
    }
 #   endif
 }
 recursive_mutex::~recursive_mutex()
 {
    int res = 0;
    res = pthread_mutex_destroy(&m_mutex);
    assert(res == 0);
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    res = pthread_cond_destroy(&m_unlocked);
    assert(res == 0);
 #   endif
 }
 void recursive_mutex::do_lock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    if (++m_count > 1)
    {
        res = pthread_mutex_unlock(&m_mutex);
        assert(res == 0);
    }
 #   else
    pthread_t tid = pthread_self();
    if (m_valid_id && pthread_equal(m_thread_id, tid))
        ++m_count;
    else
    {
        while (m_valid_id)
        {
            res = pthread_cond_wait(&m_unlocked, &m_mutex);
            assert(res == 0);
        }
        m_thread_id = tid;
        m_valid_id = true;
        m_count = 1;
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 #   endif
 }
 void recursive_mutex::do_unlock()
 {
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    if (--m_count == 0)
    {
        int res = 0;
        res = pthread_mutex_unlock(&m_mutex);
        assert(res == 0);
    }
 #   else
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    pthread_t tid = pthread_self();
    if (m_valid_id && !pthread_equal(m_thread_id, tid))
    {
        res = pthread_mutex_unlock(&m_mutex);
        assert(res == 0);
        throw lock_error();
    }
    if (--m_count == 0)
    {
        assert(m_valid_id);
        m_valid_id = false;
        res = pthread_cond_signal(&m_unlocked);
        assert(res == 0);
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 #   endif
 }
 void recursive_mutex::do_lock(cv_state& state)
 {
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    m_count = state.count;
 #   else
    int res = 0;
    while (m_valid_id)
    {
        res = pthread_cond_wait(&m_unlocked, &m_mutex);
        assert(res == 0);
    }
    m_thread_id = pthread_self();
    m_valid_id = true;
    m_count = state.count;
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 #   endif
 }
 void recursive_mutex::do_unlock(cv_state& state)
 {
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    assert(m_valid_id);
    m_valid_id = false;
    res = pthread_cond_signal(&m_unlocked);
    assert(res == 0);
 #   endif
    state.pmutex = &m_mutex;
    state.count = m_count;
 }
 recursive_try_mutex::recursive_try_mutex()
    : m_count(0)
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    , m_valid_id(false)
 #   endif
 {
    pthread_mutexattr_t attr;
    int res = 0;
    res = pthread_mutexattr_init(&attr);
    assert(res == 0);
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    assert(res == 0);
 #   endif
    res = pthread_mutex_init(&m_mutex, &attr);
    if (res != 0)
        throw thread_resource_error();
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    res = pthread_cond_init(&m_unlocked, 0);
    if (res != 0)
    {
        pthread_mutex_destroy(&m_mutex);
        throw thread_resource_error();
    }
 #   endif
 }
 recursive_try_mutex::~recursive_try_mutex()
 {
    int res = 0;
    res = pthread_mutex_destroy(&m_mutex);
    assert(res == 0);
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    res = pthread_cond_destroy(&m_unlocked);
    assert(res == 0);
 #   endif
 }
 void recursive_try_mutex::do_lock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    if (++m_count > 1)
    {
        res = pthread_mutex_unlock(&m_mutex);
        assert(res == 0);
    }
 #   else
    pthread_t tid = pthread_self();
    if (m_valid_id && pthread_equal(m_thread_id, tid))
        ++m_count;
    else
    {
        while (m_valid_id)
        {
            res = pthread_cond_wait(&m_unlocked, &m_mutex);
            assert(res == 0);
        }
        m_thread_id = tid;
        m_valid_id = true;
        m_count = 1;
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 #   endif
 }
 bool recursive_try_mutex::do_trylock()
 {
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    int res = 0;
    res = pthread_mutex_trylock(&m_mutex);
    assert(res == 0);
    if (res == 0)
    {
        if (++m_count > 1)
        {
            res = pthread_mutex_unlock(&m_mutex);
            assert(res == 0);
        }
        return true;
    }
    return false;
 #   else
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    bool ret = false;
    pthread_t tid = pthread_self();
    if (m_valid_id && pthread_equal(m_thread_id, tid))
    {
        ++m_count;
        ret = true;
    }
    else if (!m_valid_id)
    {
        m_thread_id = tid;
        m_valid_id = true;
        m_count = 1;
        ret = true;
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
    return ret;
 #   endif
 }
 void recursive_try_mutex::do_unlock()
 {
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    if (--m_count == 0)
    {
        int res = 0;
        res = pthread_mutex_unlock(&m_mutex);
        assert(res == 0);
    }
 #   else
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    pthread_t tid = pthread_self();
    if (m_valid_id && !pthread_equal(m_thread_id, tid))
    {
        res = pthread_mutex_unlock(&m_mutex);
        assert(res == 0);
        throw lock_error();
    }
    if (--m_count == 0)
    {
        assert(m_valid_id);
        m_valid_id = false;
        res = pthread_cond_signal(&m_unlocked);
        assert(res == 0);
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 #   endif
 }
 void recursive_try_mutex::do_lock(cv_state& state)
 {
 #   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    m_count = state.count;
 #   else
    int res = 0;
    while (m_valid_id)
    {
        res = pthread_cond_wait(&m_unlocked, &m_mutex);
        assert(res == 0);
    }
    m_thread_id = pthread_self();
    m_valid_id = true;
    m_count = state.count;
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 #   endif
 }
 void recursive_try_mutex::do_unlock(cv_state& state)
 {
 #   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    assert(m_valid_id);
    m_valid_id = false;
    res = pthread_cond_signal(&m_unlocked);
    assert(res == 0);
 #   endif
    state.pmutex = &m_mutex;
    state.count = m_count;
 }
 recursive_timed_mutex::recursive_timed_mutex()
    : m_valid_id(false), m_count(0)
 {
    int res = 0;
    res = pthread_mutex_init(&m_mutex, 0);
    if (res != 0)
        throw thread_resource_error();
    res = pthread_cond_init(&m_unlocked, 0);
    if (res != 0)
    {
        pthread_mutex_destroy(&m_mutex);
        throw thread_resource_error();
    }
 }
 recursive_timed_mutex::~recursive_timed_mutex()
 {
    int res = 0;
    res = pthread_mutex_destroy(&m_mutex);
    assert(res == 0);
    res = pthread_cond_destroy(&m_unlocked);
    assert(res == 0);
 }
 void recursive_timed_mutex::do_lock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    pthread_t tid = pthread_self();
    if (m_valid_id && pthread_equal(m_thread_id, tid))
        ++m_count;
    else
    {
        while (m_valid_id)
        {
            res = pthread_cond_wait(&m_unlocked, &m_mutex);
            assert(res == 0);
        }
        m_thread_id = tid;
        m_valid_id = true;
        m_count = 1;
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 }
 bool recursive_timed_mutex::do_trylock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    bool ret = false;
    pthread_t tid = pthread_self();
    if (m_valid_id && pthread_equal(m_thread_id, tid))
    {
        ++m_count;
        ret = true;
    }
    else if (!m_valid_id)
    {
        m_thread_id = tid;
        m_valid_id = true;
        m_count = 1;
        ret = true;
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
    return ret;
 }
 bool recursive_timed_mutex::do_timedlock(const xtime& xt)
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    bool ret = false;
    pthread_t tid = pthread_self();
    if (m_valid_id && pthread_equal(m_thread_id, tid))
    {
        ++m_count;
        ret = true;
    }
    else
    {
        timespec ts;
        to_timespec(xt, ts);
        while (m_valid_id)
        {
            res = pthread_cond_timedwait(&m_unlocked, &m_mutex, &ts);
            if (res == ETIMEDOUT)
                break;
            assert(res == 0);
        }
        if (!m_valid_id)
        {
            m_thread_id = tid;
            m_valid_id = true;
            m_count = 1;
            ret = true;
        }
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
    return ret;
 }
 void recursive_timed_mutex::do_unlock()
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    pthread_t tid = pthread_self();
    if (m_valid_id && !pthread_equal(m_thread_id, tid))
    {
        res = pthread_mutex_unlock(&m_mutex);
        assert(res == 0);
        throw lock_error();
    }
    if (--m_count == 0)
    {
        assert(m_valid_id);
        m_valid_id = false;
        res = pthread_cond_signal(&m_unlocked);
        assert(res == 0);
    }
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 }
 void recursive_timed_mutex::do_lock(cv_state& state)
 {
    int res = 0;
    while (m_valid_id)
    {
        res = pthread_cond_wait(&m_unlocked, &m_mutex);
        assert(res == 0);
    }
    m_thread_id = pthread_self();
    m_valid_id = true;
    m_count = state.count;
    res = pthread_mutex_unlock(&m_mutex);
    assert(res == 0);
 }
 void recursive_timed_mutex::do_unlock(cv_state& state)
 {
    int res = 0;
    res = pthread_mutex_lock(&m_mutex);
    assert(res == 0);
    assert(m_valid_id);
    m_valid_id = false;
    res = pthread_cond_signal(&m_unlocked);
    assert(res == 0);
    state.pmutex = &m_mutex;
    state.count = m_count;
 }
 #elif defined(BOOST_HAS_MPTASKS)
 using threads::mac::detail::safe_enter_critical_region;
 recursive_mutex::recursive_mutex()
    : m_count(0)
 {
 }
 recursive_mutex::~recursive_mutex()
 {
 }
 void recursive_mutex::do_lock()
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    if (++m_count > 1)
    {
        lStatus = MPExitCriticalRegion(m_mutex);
        assert(lStatus == noErr);
    }
 }
 void recursive_mutex::do_unlock()
 {
    if (--m_count == 0)
    {
        OSStatus lStatus = noErr;
        lStatus = MPExitCriticalRegion(m_mutex);
        assert(lStatus == noErr);
    }
 }
 void recursive_mutex::do_lock(cv_state& state)
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    m_count = state;
 }
 void recursive_mutex::do_unlock(cv_state& state)
 {
    state = m_count;
    m_count = 0;
    OSStatus lStatus = noErr;
    lStatus = MPExitCriticalRegion(m_mutex);
    assert(lStatus == noErr);
 }
 recursive_try_mutex::recursive_try_mutex()
    : m_count(0)
 {
 }
 recursive_try_mutex::~recursive_try_mutex()
 {
 }
 void recursive_try_mutex::do_lock()
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    if (++m_count > 1)
    {
        lStatus = MPExitCriticalRegion(m_mutex);
        assert(lStatus == noErr);
    }
 }
 bool recursive_try_mutex::do_trylock()
 {
    OSStatus lStatus = noErr;
    lStatus = MPEnterCriticalRegion(m_mutex, kDurationImmediate);
    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
    if (lStatus == noErr)
    {
        if (++m_count > 1)
        {
            lStatus = MPExitCriticalRegion(m_mutex);
            assert(lStatus == noErr);
        }
        return true;
    }
    return false;
 }
 void recursive_try_mutex::do_unlock()
 {
    if (--m_count == 0)
    {
        OSStatus lStatus = noErr;
        lStatus = MPExitCriticalRegion(m_mutex);
        assert(lStatus == noErr);
    }
 }
 void recursive_try_mutex::do_lock(cv_state& state)
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    m_count = state;
 }
 void recursive_try_mutex::do_unlock(cv_state& state)
 {
    state = m_count;
    m_count = 0;
    OSStatus lStatus = noErr;
    lStatus = MPExitCriticalRegion(m_mutex);
    assert(lStatus == noErr);
 }
 recursive_timed_mutex::recursive_timed_mutex()
    : m_count(0)
 {
 }
 recursive_timed_mutex::~recursive_timed_mutex()
 {
 }
 void recursive_timed_mutex::do_lock()
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    if (++m_count > 1)
    {
        lStatus = MPExitCriticalRegion(m_mutex);
        assert(lStatus == noErr);
    }
 }
 bool recursive_timed_mutex::do_trylock()
 {
    OSStatus lStatus = noErr;
    lStatus = MPEnterCriticalRegion(m_mutex, kDurationImmediate);
    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
    if (lStatus == noErr)
    {
        if (++m_count > 1)
        {
            lStatus = MPExitCriticalRegion(m_mutex);
            assert(lStatus == noErr);
        }
        return true;
    }
    return false;
 }
 bool recursive_timed_mutex::do_timedlock(const xtime& xt)
 {
    int microseconds;
    to_microduration(xt, microseconds);
    Duration lDuration = kDurationMicrosecond * microseconds;
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, lDuration, m_mutex_mutex);
    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
    if (lStatus == noErr)
    {
        if (++m_count > 1)
        {
            lStatus = MPExitCriticalRegion(m_mutex);
            assert(lStatus == noErr);
        }
        return true;
    }
    return false;
 }
 void recursive_timed_mutex::do_unlock()
 {
    if (--m_count == 0)
    {
        OSStatus lStatus = noErr;
        lStatus = MPExitCriticalRegion(m_mutex);
        assert(lStatus == noErr);
    }
 }
 void recursive_timed_mutex::do_lock(cv_state& state)
 {
    OSStatus lStatus = noErr;
    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
    assert(lStatus == noErr);
    m_count = state;
 }
 void recursive_timed_mutex::do_unlock(cv_state& state)
 {
    state = m_count;
    m_count = 0;
    OSStatus lStatus = noErr;
    lStatus = MPExitCriticalRegion(m_mutex);
    assert(lStatus == noErr);
 }
 #endif
 } // namespace boost
 // Change Log:
 //   8 Feb 01  WEKEMPF Initial version.
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -0,0 +1,315 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/thread/condition.hpp>
 #include <cassert>
 #if defined(BOOST_HAS_WINTHREADS)
 #   include <windows.h>
 #   include <process.h>
 #elif defined(BOOST_HAS_MPTASKS)
 #    include <DriverServices.h>
 #    include "init.hpp"
 #    include "safe.hpp"
 #    include <boost/thread/tss.hpp>
 #endif
 #include "timeconv.inl"
 namespace {
 class thread_param
 {
 public:
    thread_param(const boost::function0<void>& threadfunc) : m_threadfunc(threadfunc), m_started(false) { }
    void wait()
    {
        boost::mutex::scoped_lock scoped_lock(m_mutex);
        while (!m_started)
            m_condition.wait(scoped_lock);
    }
    void started()
    {
        boost::mutex::scoped_lock scoped_lock(m_mutex);
        m_started = true;
        m_condition.notify_one();
    }
    boost::mutex m_mutex;
    boost::condition m_condition;
    const boost::function0<void>& m_threadfunc;
    bool m_started;
 };
 } // unnamed namespace
 extern "C" {
 #if defined(BOOST_HAS_WINTHREADS)
 unsigned __stdcall thread_proxy(void* param)
 #elif defined(BOOST_HAS_PTHREADS)
 static void* thread_proxy(void* param)
 #elif defined(BOOST_HAS_MPTASKS)
 static OSStatus thread_proxy(void* param)
 #endif
 {
    try
    {
        thread_param* p = static_cast<thread_param*>(param);
        boost::function0<void> threadfunc = p->m_threadfunc;
        p->started();
        threadfunc();
    }
    catch (...)
    {
    }
 #if defined(BOOST_HAS_MPTASKS)
    ::boost::detail::thread_cleanup();
 #endif
    return 0;
 }
 }
 namespace boost {
 thread::thread()
    : m_joinable(false)
 {
 #if defined(BOOST_HAS_WINTHREADS)
    m_thread = reinterpret_cast<void*>(GetCurrentThread());
    m_id = GetCurrentThreadId();
 #elif defined(BOOST_HAS_PTHREADS)
    m_thread = pthread_self();
 #elif defined(BOOST_HAS_MPTASKS)
    threads::mac::detail::thread_init();
    threads::mac::detail::create_singletons();
    m_pTaskID = MPCurrentTaskID();
    m_pJoinQueueID = kInvalidID;
 #endif
 }
 thread::thread(const function0<void>& threadfunc)
    : m_joinable(true)
 {
    thread_param param(threadfunc);
 #if defined(BOOST_HAS_WINTHREADS)
    m_thread = reinterpret_cast<void*>(_beginthreadex(0, 0, &thread_proxy, &param, 0, &m_id));
    if (!m_thread)
        throw thread_resource_error();
 #elif defined(BOOST_HAS_PTHREADS)
    int res = 0;
    res = pthread_create(&m_thread, 0, &thread_proxy, &param);
    if (res != 0)
        throw thread_resource_error();
 #elif defined(BOOST_HAS_MPTASKS)
    threads::mac::detail::thread_init();
    threads::mac::detail::create_singletons();
    OSStatus lStatus = noErr;
    m_pJoinQueueID = kInvalidID;
    m_pTaskID = kInvalidID;
    lStatus = MPCreateQueue(&m_pJoinQueueID);
    if(lStatus != noErr) throw thread_resource_error();
    lStatus = MPCreateTask(&thread_proxy, &param, 0UL, m_pJoinQueueID, NULL, NULL,
                            0UL, &m_pTaskID);
    if(lStatus != noErr)
    {
        lStatus = MPDeleteQueue(m_pJoinQueueID);
        assert(lStatus == noErr);
        throw thread_resource_error();
    }
 #endif
    param.wait();
 }
 thread::~thread()
 {
    if (m_joinable)
    {
 #if defined(BOOST_HAS_WINTHREADS)
        int res = 0;
        res = CloseHandle(reinterpret_cast<HANDLE>(m_thread));
        assert(res);
 #elif defined(BOOST_HAS_PTHREADS)
        pthread_detach(m_thread);
 #elif defined(BOOST_HAS_MPTASKS)
        assert(m_pJoinQueueID != kInvalidID);
        OSStatus lStatus = MPDeleteQueue(m_pJoinQueueID);
        assert(lStatus == noErr);
 #endif
    }
 }
 bool thread::operator==(const thread& other) const
 {
 #if defined(BOOST_HAS_WINTHREADS)
    return other.m_id == m_id;
 #elif defined(BOOST_HAS_PTHREADS)
    return pthread_equal(m_thread, other.m_thread) != 0;
 #elif defined(BOOST_HAS_MPTASKS)
    return other.m_pTaskID == m_pTaskID;
 #endif
 }
 bool thread::operator!=(const thread& other) const
 {
    return !operator==(other);
 }
 void thread::join()
 {
    int res = 0;
 #if defined(BOOST_HAS_WINTHREADS)
    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_thread), INFINITE);
    assert(res == WAIT_OBJECT_0);
    res = CloseHandle(reinterpret_cast<HANDLE>(m_thread));
    assert(res);
 #elif defined(BOOST_HAS_PTHREADS)
    res = pthread_join(m_thread, 0);
    assert(res == 0);
 #elif defined(BOOST_HAS_MPTASKS)
    OSStatus lStatus = threads::mac::detail::safe_wait_on_queue(m_pJoinQueueID, NULL, NULL, NULL, kDurationForever);
    assert(lStatus == noErr);
 #endif
    // This isn't a race condition since any race that could occur would
    // have us in undefined behavior territory any way.
    m_joinable = false;
 }
 void thread::sleep(const xtime& xt)
 {
 	for (;;)
 	{
 #if defined(BOOST_HAS_WINTHREADS)
 		int milliseconds;
 		to_duration(xt, milliseconds);
 		Sleep(milliseconds);
 		xtime xt2;
 		xtime_get(&xt2, TIME_UTC);
 #elif defined(BOOST_HAS_PTHREADS)
 #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
 		timespec ts;
 		to_timespec_duration(xt, ts);
 		int res = 0;
 		res = pthread_delay_np(&ts);
 		assert(res == 0);
 #   elif defined(BOOST_HAS_NANOSLEEP)
 		timespec ts;
 		to_timespec_duration(xt, ts);
 		//  nanosleep takes a timespec that is an offset, not
 		//  an absolute time.
 		nanosleep(&ts, 0);
 #   else
 		mutex mx;
 		mutex::scoped_lock lock(mx);
 		condition cond;
 		cond.timed_wait(lock, xt);
 #   endif
 #elif defined(BOOST_HAS_MPTASKS)
 		int microseconds;
 		to_microduration(xt, microseconds);
 		Duration lMicroseconds(kDurationMicrosecond * microseconds);
 		AbsoluteTime sWakeTime(DurationToAbsolute(lMicroseconds));
 		threads::mac::detail::safe_delay_until(&sWakeTime);
 #endif
 		if (xtime_cmp(xt, xt2) >= 0)
 			return;
 	}
 }
 void thread::yield()
 {
 #if defined(BOOST_HAS_WINTHREADS)
    Sleep(0);
 #elif defined(BOOST_HAS_PTHREADS)
 #   if defined(BOOST_HAS_SCHED_YIELD)
    int res = 0;
    res = sched_yield();
    assert(res == 0);
 #   elif defined(BOOST_HAS_PTHREAD_YIELD)
    int res = 0;
    res = pthread_yield();
    assert(res == 0);
 #   else
    xtime xt;
    xtime_get(&xt, TIME_UTC);
    sleep(xt);
 #   endif
 #elif defined(BOOST_HAS_MPTASKS)
    MPYield();
 #endif
 }
 thread_group::thread_group()
 {
 }
 thread_group::~thread_group()
 {
    // We shouldn't have to scoped_lock here, since referencing this object from another thread
    // while we're deleting it in the current thread is going to lead to undefined behavior
    // any way.
    for (std::list<thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
        delete (*it);
 }
 thread* thread_group::create_thread(const function0<void>& threadfunc)
 {
    // No scoped_lock required here since the only "shared data" that's modified here occurs
    // inside add_thread which does scoped_lock.
    std::auto_ptr<thread> thrd(new thread(threadfunc));
    add_thread(thrd.get());
    return thrd.release();
 }
 void thread_group::add_thread(thread* thrd)
 {
    mutex::scoped_lock scoped_lock(m_mutex);
    // For now we'll simply ignore requests to add a thread object multiple times.
    // Should we consider this an error and either throw or return an error value?
    std::list<thread*>::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
    assert(it == m_threads.end());
    if (it == m_threads.end())
        m_threads.push_back(thrd);
 }
 void thread_group::remove_thread(thread* thrd)
 {
    mutex::scoped_lock scoped_lock(m_mutex);
    // For now we'll simply ignore requests to remove a thread object that's not in the group.
    // Should we consider this an error and either throw or return an error value?
    std::list<thread*>::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
    assert(it != m_threads.end());
    if (it != m_threads.end())
        m_threads.erase(it);
 }
 void thread_group::join_all()
 {
    mutex::scoped_lock scoped_lock(m_mutex);
    for (std::list<thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
        (*it)->join();
 }
 } // namespace boost
 // Change Log:
 //    8 Feb 01  WEKEMPF Initial version.
 //    1 Jun 01  WEKEMPF Added boost::thread initial implementation.
 //    3 Jul 01  WEKEMPF Redesigned boost::thread to be noncopyable.
--- a/src/threadmon.cpp
+++ b/src/threadmon.cpp
@@ -0,0 +1,146 @@
 // threadmon.cpp : Defines the entry point for the DLL application.
 //
 #define BOOST_THREADMON_EXPORTS
 #include "threadmon.hpp"
 #ifdef BOOST_HAS_WINTHREADS
 #define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers
 #include <windows.h>
 #ifdef BOOST_MSVC
 #   pragma warning(disable : 4786)
 #endif
 #include <list>
 #include <set>
 #include <algorithm>
 typedef void (__cdecl * handler)(void);
 typedef std::list<handler> exit_handlers;
 typedef std::set<exit_handlers*> registered_handlers;
 namespace
 {
    CRITICAL_SECTION cs;
    DWORD key;
    registered_handlers registry;
 }
 #if defined(__BORLANDC__)
 #define DllMain DllEntryPoint
 #endif
 extern "C"
 BOOL WINAPI DllMain(HANDLE module, DWORD reason, LPVOID)
 {
    switch (reason)
    {
        case DLL_PROCESS_ATTACH:
            InitializeCriticalSection(&cs);
            key = TlsAlloc();
            break;
        case DLL_THREAD_ATTACH:
            break;
        case DLL_THREAD_DETACH:
            {
                // Call the thread's exit handlers.
                exit_handlers* handlers = static_cast<exit_handlers*>(TlsGetValue(key));
                if (handlers)
                {
                    for (exit_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
                        (*it)();
                    // Remove the exit handler list from the registered lists and then destroy it.
                    EnterCriticalSection(&cs);
                    registry.erase(handlers);
                    LeaveCriticalSection(&cs);
                    delete handlers;
                }
            }
            break;
        case DLL_PROCESS_DETACH:
            {
                // Assume the main thread is ending (call its handlers) and all other threads
                // have already ended.  If this DLL is loaded and unloaded dynamically at run time
                // this is a bad assumption, but this is the best we can do.
                exit_handlers* handlers = static_cast<exit_handlers*>(TlsGetValue(key));
                if (handlers)
                {
                    for (exit_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
                        (*it)();
                }
                // Destroy any remaining exit handlers.  Above we assumed there'd only be the main
                // thread left, but to insure we don't get memory leaks we won't make that assumption
                // here.
                EnterCriticalSection(&cs);
                for (registered_handlers::iterator it = registry.begin(); it != registry.end(); ++it)
                    delete (*it);
                LeaveCriticalSection(&cs);
                DeleteCriticalSection(&cs);
                TlsFree(key);
            }
            break;
    }
    return TRUE;
 }
 int on_thread_exit(void (__cdecl * func)(void))
 {
    // Get the exit handlers for the current thread, creating and registering
    // one if it doesn't exist.
    exit_handlers* handlers = static_cast<exit_handlers*>(TlsGetValue(key));
    if (!handlers)
    {
        try
        {
            handlers = new exit_handlers;
            // Handle "broken" implementations of operator new that don't throw.
            if (!handlers)
                return -1;
        }
        catch (...)
        {
            return -1;
        }
        // Attempt to set a TLS value for the new handlers.
        if (!TlsSetValue(key, handlers))
        {
            delete handlers;
            return -1;
        }
        // Attempt to register this new handler so that memory can be properly
        // cleaned up.
        try
        {
            EnterCriticalSection(&cs);
            registry.insert(handlers);
            LeaveCriticalSection(&cs);
        }
        catch (...)
        {
            LeaveCriticalSection(&cs);
            delete handlers;
            return -1;
        }
    }
    // Attempt to add the handler to the list of exit handlers. If it's been previously
    // added just report success and exit.
    try
    {
        handlers->push_front(func);
    }
    catch (...)
    {
        return -1;
    }
    return 0;
 }
 #endif // BOOST_HAS_WINTHREADS
--- a/src/threadmon.hpp
+++ b/src/threadmon.hpp
@@ -0,0 +1,23 @@
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 #   error   Thread support is unavailable!
 #endif
 #ifdef BOOST_HAS_WINTHREADS
 // The following ifdef block is the standard way of creating macros which make exporting
 // from a DLL simpler. All files within this DLL are compiled with the BOOST_THREADMON_EXPORTS
 // symbol defined on the command line. this symbol should not be defined on any project
 // that uses this DLL. This way any other project whose source files include this file see
 // BOOST_THREADMON_API functions as being imported from a DLL, wheras this DLL sees symbols
 // defined with this macro as being exported.
 #ifdef BOOST_THREADMON_EXPORTS
 #define BOOST_THREADMON_API __declspec(dllexport)
 #else
 #define BOOST_THREADMON_API __declspec(dllimport)
 #endif
 extern "C" BOOST_THREADMON_API int on_thread_exit(void (__cdecl * func)(void));
 #endif // BOOST_HAS_WINTHREADS
--- a/src/timeconv.inl
+++ b/src/timeconv.inl
@@ -0,0 +1,122 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 namespace {
    const int MILLISECONDS_PER_SECOND = 1000;
    const int NANOSECONDS_PER_SECOND = 1000000000;
    const int NANOSECONDS_PER_MILLISECOND = 1000000;
    const int MICROSECONDS_PER_SECOND = 1000000;
    const int NANOSECONDS_PER_MICROSECOND = 1000;
    inline void to_time(int milliseconds, boost::xtime& xt)
    {
        int res = 0;
        res = boost::xtime_get(&xt, boost::TIME_UTC);
        assert(res == boost::TIME_UTC);
        xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
        xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND);
        if (xt.nsec > static_cast<const int>(NANOSECONDS_PER_SECOND))
        {
            ++xt.sec;
            xt.nsec -= NANOSECONDS_PER_SECOND;
        }
    }
 #if defined(BOOST_HAS_PTHREADS)
    inline void to_timespec(const boost::xtime& xt, timespec& ts)
    {
        ts.tv_sec = static_cast<int>(xt.sec);
        ts.tv_nsec = static_cast<int>(xt.nsec);
        if(ts.tv_nsec > static_cast<const int>(NANOSECONDS_PER_SECOND))
        {
            ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
            ts.tv_nsec %= NANOSECONDS_PER_SECOND;
        }
    }
    inline void to_time(int milliseconds, timespec& ts)
    {
        boost::xtime xt;
        to_time(milliseconds, xt);
        to_timespec(xt, ts);
    }
    inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
    {
        boost::xtime cur;
        int res = 0;
        res = boost::xtime_get(&cur, boost::TIME_UTC);
        assert(res == boost::TIME_UTC);
        if (xt.sec < cur.sec || (xt.sec == cur.sec && xt.nsec < cur.nsec))
        {
            ts.tv_sec = 0;
            ts.tv_nsec = 0;
        }
        else
        {
            ts.tv_sec = xt.sec - cur.sec;
            ts.tv_nsec = xt.nsec - cur.nsec;
            if( ts.tv_nsec < 0 )
            {
                ts.tv_sec -= 1;
                ts.tv_nsec += NANOSECONDS_PER_SECOND;
            }
           if(ts.tv_nsec > static_cast<const int>(NANOSECONDS_PER_SECOND))
           {
               ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
               ts.tv_nsec %= NANOSECONDS_PER_SECOND;
           }
        }
    }
 #endif
    inline void to_duration(const boost::xtime& xt, int& milliseconds)
    {
        boost::xtime cur;
        int res = 0;
        res = boost::xtime_get(&cur, boost::TIME_UTC);
        assert(res == boost::TIME_UTC);
        if (xt.sec < cur.sec || (xt.sec == cur.sec && xt.nsec < cur.nsec))
            milliseconds = 0;
        else
        {
            milliseconds = ((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +
                (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) /
                NANOSECONDS_PER_MILLISECOND);
        }
    }
    inline void to_microduration(const boost::xtime& xt, int& microseconds)
    {
        boost::xtime cur;
        int res = 0;
        res = boost::xtime_get(&cur, boost::TIME_UTC);
        assert(res == boost::TIME_UTC);
        if (xt.sec < cur.sec || (xt.sec == cur.sec && xt.nsec < cur.nsec))
            microseconds = 0;
        else
        {
            microseconds = ((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) +
                (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MICROSECOND/2)) /
                NANOSECONDS_PER_MICROSECOND);
        }
    }
 }
 // Change Log:
 //    1 Jun 01  Initial creation.
--- a/src/tss.cpp
+++ b/src/tss.cpp
@@ -0,0 +1,247 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #include <boost/thread/tss.hpp>
 #include <boost/thread/once.hpp>
 #include <boost/thread/exceptions.hpp>
 #include <stdexcept>
 #include <cassert>
 #if defined(BOOST_HAS_WINTHREADS)
 #   include <windows.h>
 #endif
 #if defined(BOOST_HAS_WINTHREADS)
 #include "threadmon.hpp"
 #include <map>
 namespace {
    typedef std::pair<void(*)(void*), void*> cleanup_info;
    typedef std::map<int, cleanup_info> cleanup_handlers;
    DWORD key;
    boost::once_flag once = BOOST_ONCE_INIT;
    void init_cleanup_key()
    {
        key = TlsAlloc();
        assert(key != 0xFFFFFFFF);
    }
    void __cdecl cleanup()
    {
        cleanup_handlers* handlers = static_cast<cleanup_handlers*>(TlsGetValue(key));
        for (cleanup_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
        {
            cleanup_info info = it->second;
            if (info.second)
                info.first(info.second);
        }
        delete handlers;
    }
    cleanup_handlers* get_handlers()
    {
        boost::call_once(&init_cleanup_key, once);
        cleanup_handlers* handlers = static_cast<cleanup_handlers*>(TlsGetValue(key));
        if (!handlers)
        {
            try
            {
                handlers = new cleanup_handlers;
            }
            catch (...)
            {
                return 0;
            }
            int res = 0;
            res = TlsSetValue(key, handlers);
            assert(res);
            res = on_thread_exit(&cleanup);
            assert(res == 0);
        }
        return handlers;
    }
 }
 #elif defined(BOOST_HAS_MPTASKS)
 #include <map>
 namespace {
    typedef std::pair<void(*)(void*), void*> cleanup_info;
    typedef std::map<int, cleanup_info> cleanup_handlers;
    TaskStorageIndex key;
    boost::once_flag once = BOOST_ONCE_INIT;
    void init_cleanup_key()
    {
        OSStatus lStatus = MPAllocateTaskStorageIndex(&key);
        assert(lStatus == noErr);
    }
    cleanup_handlers* get_handlers()
    {
        boost::call_once(&init_cleanup_key, once);
        cleanup_handlers* handlers = reinterpret_cast<cleanup_handlers*>(MPGetTaskStorageValue(key));
        if (!handlers)
        {
            try
            {
                handlers = new cleanup_handlers;
            }
            catch (...)
            {
                return 0;
            }
            OSStatus lStatus = noErr;
            lStatus = MPSetTaskStorageValue(key, reinterpret_cast<TaskStorageValue>(handlers));
            assert(lStatus == noErr);
        // TODO - create a generalized mechanism for registering thread exit functions
        //            and use it here.
        }
        return handlers;
    }
 }
 namespace boost {
 namespace detail {
 void thread_cleanup()
 {
    cleanup_handlers* handlers = reinterpret_cast<cleanup_handlers*>(MPGetTaskStorageValue(key));
    if(handlers != NULL)
    {
        for (cleanup_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
        {
            cleanup_info info = it->second;
            if (info.second)
                info.first(info.second);
        }
        delete handlers;
    }
 }
 } // namespace detail
 } // namespace boost
 #endif
 namespace boost { namespace detail {
 #if defined(BOOST_HAS_WINTHREADS)
 tss::tss(void (*cleanup)(void*))
 {
    m_key = TlsAlloc();
    if (m_key == 0xFFFFFFFF)
        throw thread_resource_error();
    m_cleanup = cleanup;
 }
 tss::~tss()
 {
    int res = 0;
    res = TlsFree(m_key);
    assert(res);
 }
 void* tss::get() const
 {
    return TlsGetValue(m_key);
 }
 bool tss::set(void* value)
 {
    if (value && m_cleanup)
    {
        cleanup_handlers* handlers = get_handlers();
        assert(handlers);
        if (!handlers)
            return false;
        cleanup_info info(m_cleanup, value);
        (*handlers)[m_key] = info;
    }
    return !!TlsSetValue(m_key, value);
 }
 #elif defined(BOOST_HAS_PTHREADS)
 tss::tss(void (*cleanup)(void*))
 {
    int res = 0;
    res = pthread_key_create(&m_key, cleanup);
    if (res != 0)
        throw thread_resource_error();
 }
 tss::~tss()
 {
    int res = 0;
    res = pthread_key_delete(m_key);
    assert(res == 0);
 }
 void* tss::get() const
 {
    return pthread_getspecific(m_key);
 }
 bool tss::set(void* value)
 {
    return pthread_setspecific(m_key, value) == 0;
 }
 #elif defined(BOOST_HAS_MPTASKS)
 tss::tss(void (*cleanup)(void*))
 {
    OSStatus lStatus = MPAllocateTaskStorageIndex(&m_key);
    if(lStatus != noErr)
        throw thread_resource_error();
    m_cleanup = cleanup;
 }
 tss::~tss()
 {
    OSStatus lStatus = MPDeallocateTaskStorageIndex(m_key);
    assert(lStatus == noErr);
 }
 void* tss::get() const
 {
    TaskStorageValue ulValue = MPGetTaskStorageValue(m_key);
    return(reinterpret_cast<void *>(ulValue));
 }
 bool tss::set(void* value)
 {
    if (value && m_cleanup)
    {
        cleanup_handlers* handlers = get_handlers();
        assert(handlers);
        if (!handlers)
            return false;
        cleanup_info info(m_cleanup, value);
        (*handlers)[m_key] = info;
    }
    OSStatus lStatus = MPSetTaskStorageValue(m_key, reinterpret_cast<TaskStorageValue>(value));
    return(lStatus == noErr);
 }
 #endif
 } // namespace detail
 } // namespace boost
 // Change Log:
 //   6 Jun 01  WEKEMPF Initial version.
--- a/src/xtime.cpp
+++ b/src/xtime.cpp
@@ -0,0 +1,120 @@
 // Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
 // that both that copyright notice and this permission notice appear
 // in supporting documentation.  William E. Kempf makes no representations
 // about the suitability of this software for any purpose.
 // It is provided "as is" without express or implied warranty.
 #include <boost/thread/xtime.hpp>
 #if defined(BOOST_HAS_FTIME)
 #   include <windows.h>
 #elif defined(BOOST_HAS_GETTIMEOFDAY)
 #   include <sys/time.h>
 #elif defined(BOOST_HAS_MPTASKS)
 #   include <DriverServices.h>
 #   include <boost/thread/detail/force_cast.hpp>
 #endif
 namespace boost {
 #ifdef BOOST_HAS_MPTASKS
 namespace detail
 {
 using thread::force_cast;
 struct startup_time_info
 {
    startup_time_info()
    {
    // 1970 Jan 1 at 00:00:00
        static const DateTimeRec k_sUNIXBase = {1970, 1, 1, 0, 0, 0, 0};
        static unsigned long s_ulUNIXBaseSeconds = 0UL;
        if(s_ulUNIXBaseSeconds == 0UL)
        {
        // calculate the number of seconds between the Mac OS base and the UNIX base
        //    the first time we enter this constructor.
            DateToSeconds(&k_sUNIXBase, &s_ulUNIXBaseSeconds);
        }
        unsigned long ulSeconds;
    // get the time in UpTime units twice, with the time in seconds in the middle.
        uint64_t ullFirstUpTime = force_cast<uint64_t>(UpTime());
        GetDateTime(&ulSeconds);
        uint64_t ullSecondUpTime = force_cast<uint64_t>(UpTime());
    // calculate the midpoint of the two UpTimes, and save that.
        uint64_t ullAverageUpTime = (ullFirstUpTime + ullSecondUpTime) / 2ULL;
        m_sStartupAbsoluteTime = force_cast<AbsoluteTime>(ullAverageUpTime);
    // save the number of seconds, recentered at the UNIX base.
        m_ulStartupSeconds = ulSeconds - s_ulUNIXBaseSeconds;
    }
    AbsoluteTime m_sStartupAbsoluteTime;
    UInt32 m_ulStartupSeconds;
 };
 static startup_time_info g_sStartupTimeInfo;
 } // namespace detail
 #endif
 int xtime_get(struct xtime* xtp, int clock_type)
 {
    if (clock_type == TIME_UTC)
    {
 #if defined(BOOST_HAS_FTIME)
        FILETIME ft;
        GetSystemTimeAsFileTime(&ft);
        const boost::uint64_t TIMESPEC_TO_FILETIME_OFFSET = ((boost::uint64_t)27111902UL << 32) + (boost::uint64_t)3577643008UL;
        xtp->sec = (int)((*(__int64*)&ft - TIMESPEC_TO_FILETIME_OFFSET) / 10000000);
        xtp->nsec = (int)((*(__int64*)&ft - TIMESPEC_TO_FILETIME_OFFSET -
            ((__int64)xtp->sec * (__int64)10000000)) * 100);
        return clock_type;
 #elif defined(BOOST_HAS_GETTIMEOFDAY)
        struct timeval tv;
        gettimeofday(&tv, 0);
        xtp->sec = tv.tv_sec;
        xtp->nsec = tv.tv_usec * 1000;
        return clock_type;
 #elif defined(BOOST_HAS_CLOCK_GETTIME)
        timespec ts;
        clock_gettime(CLOCK_REALTIME, &ts);
        xtp->sec = ts.tv_sec;
        xtp->nsec = ts.tv_nsec;
        return clock_type;
 #elif defined(BOOST_HAS_MPTASKS)
        using detail::thread::force_cast;
    // the Mac OS does not have an MP-safe way of getting the date/time, so we use a
    //  delta from the startup time.  We _could_ defer this and use something that is
    //  interrupt-safe, but this would be _SLOW_, and we need speed here.
        const uint64_t k_ullNanosecondsPerSecond(1000ULL * 1000ULL * 1000ULL);
        AbsoluteTime sUpTime(UpTime());
        uint64_t ullNanoseconds(force_cast<uint64_t>(AbsoluteDeltaToNanoseconds(sUpTime, detail::g_sStartupTimeInfo.m_sStartupAbsoluteTime)));
        uint64_t ullSeconds = (ullNanoseconds / k_ullNanosecondsPerSecond);
        ullNanoseconds -= (ullSeconds * k_ullNanosecondsPerSecond);
        xtp->sec = detail::g_sStartupTimeInfo.m_ulStartupSeconds + ullSeconds;
        xtp->nsec = ullNanoseconds;
        return clock_type;
 #else
 #   error "xtime_get implementation undefined"
 #endif
    }
    return 0;
 }
 } // namespace boost
 // Change Log:
 //   8 Feb 01  WEKEMPF Initial version.
--- a/test/.cvsignore
+++ b/test/.cvsignore
@@ -0,0 +1,2 @@
 bin
 *.pdb
--- a/test/Carbon.r
+++ b/test/Carbon.r
@@ -0,0 +1 @@
 /*
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -0,0 +1,43 @@
 #  (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell and
 #  distribute this software is granted provided this copyright notice appears
 #  in all copies. This software is provided "as is" without express or implied
 #  warranty, and with no claim as to its suitability for any purpose.
 #
 # Boost.Threads test Jamfile
 #
 # Declares the following targets:
 #   1. test_thread, a unit test executable.
 # 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"
 # Declare the location of this subproject relative to the root.
 subproject libs/thread/test ;
 # 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.
 SEARCH on <module@>threads.jam = $(BOOST_ROOT)/libs/thread/build ;
 include <module@>threads.jam ;
 sources = test.cpp test_thread.cpp test_mutex.cpp test_condition.cpp test_tss.cpp test_once.cpp ;
 #######################
 # Declare the Boost.Threads unit test program test_thread.
 unit-test test_thread
    : $(sources)
      <lib>../build/boost_thread
      <lib>../../test/build/unit_test_framework
      $(threadmon)
    : <sysinclude>$(BOOST_ROOT)
      $(pthreads-win32)
      <threading>multi
    : debug release <runtime-link>static/dynamic
 ;
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -0,0 +1,20 @@
 #include <boost/test/unit_test.hpp>
 extern boost::unit_test_framework::test_suite* thread_tests();
 extern boost::unit_test_framework::test_suite* mutex_tests();
 extern boost::unit_test_framework::test_suite* condition_tests();
 extern boost::unit_test_framework::test_suite* tss_tests();
 extern boost::unit_test_framework::test_suite* once_tests();
 boost::unit_test_framework::test_suite* init_unit_test_suite(int argc, char* argv[])
 {
 	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads test suite");
 	test->add(thread_tests());
    test->add(mutex_tests());
 	test->add(condition_tests());
    test->add(tss_tests());
    test->add(once_tests());
    return test;
 }
--- a/test/test.mcp
+++ b/test/test.mcp
--- a/test/test_condition.cpp
+++ b/test/test_condition.cpp
@@ -0,0 +1,191 @@
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/test/unit_test.hpp>
 namespace
 {
 	struct condition_test_data
 	{
 		condition_test_data() : notified(0), awoken(0) { }
 		boost::mutex mutex;
 		boost::condition condition;
 		int notified;
 		int awoken;
 	};
 	void condition_test_thread(void* param)
 	{
 		condition_test_data* data = static_cast<condition_test_data*>(param);
 		boost::mutex::scoped_lock lock(data->mutex);
 		BOOST_CHECK(lock);
 		while (!(data->notified > 0))
 			data->condition.wait(lock);
 		BOOST_CHECK(lock);
 		data->awoken++;
 	}
 	class thread_adapter
 	{
 	public:
 		thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
 		void operator()() const { _func(_param); }
 	private:
 		void (*_func)(void*);
 		void* _param;
 	};
 	struct cond_predicate
 	{
 		cond_predicate(int& var, int val) : _var(var), _val(val) { }
 		bool operator()() { return _var == _val; }
 		int& _var;
 		int _val;
 	};
 	void condition_test_waits(void* param)
 	{
 		condition_test_data* data = static_cast<condition_test_data*>(param);
 		boost::mutex::scoped_lock lock(data->mutex);
 		BOOST_CHECK(lock);
 		// Test wait.
 		while (data->notified != 1)
 			data->condition.wait(lock);
 		BOOST_CHECK(lock);
 		BOOST_CHECK_EQUAL(data->notified, 1);
 		data->awoken++;
 		data->condition.notify_one();
 		// Test predicate wait.
 		data->condition.wait(lock, cond_predicate(data->notified, 2));
 		BOOST_CHECK(lock);
 		BOOST_CHECK_EQUAL(data->notified, 2);
 		data->awoken++;
 		data->condition.notify_one();
 		// Test timed_wait.
 		boost::xtime xt;
 		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
 		xt.nsec += 100000000;
 		while (data->notified != 3)
 			data->condition.timed_wait(lock, xt);
 		BOOST_CHECK(lock);
 		BOOST_CHECK_EQUAL(data->notified, 3);
 		data->awoken++;
 		data->condition.notify_one();
 		// Test predicate timed_wait.
 		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
 		xt.sec += 2;
 		BOOST_CHECK(data->condition.timed_wait(lock, xt, cond_predicate(data->notified, 4)));
 		BOOST_CHECK(lock);
 		BOOST_CHECK_EQUAL(data->notified, 4);
 		data->awoken++;
 	}
 }
 void test_condition_notify_one()
 {
    condition_test_data data;
    boost::thread thread(thread_adapter(&condition_test_thread, &data));
    {
        boost::mutex::scoped_lock lock(data.mutex);
        BOOST_CHECK(lock);
        data.notified++;
        data.condition.notify_one();
    }
    thread.join();
    BOOST_CHECK_EQUAL(data.awoken, 1);
 }
 void test_condition_notify_all()
 {
    const int NUMTHREADS = 5;
    boost::thread_group threads;
    condition_test_data data;
    for (int i = 0; i < NUMTHREADS; ++i)
        threads.create_thread(thread_adapter(&condition_test_thread, &data));
    {
        boost::mutex::scoped_lock lock(data.mutex);
        BOOST_CHECK(lock);
        data.notified++;
        data.condition.notify_all();
    }
    threads.join_all();
    BOOST_CHECK_EQUAL(data.awoken, NUMTHREADS);
 }
 void test_condition_waits()
 {
    condition_test_data data;
    boost::thread thread(thread_adapter(&condition_test_waits, &data));
    boost::xtime xt;
    {
        boost::mutex::scoped_lock lock(data.mutex);
        BOOST_CHECK(lock);
        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
        xt.sec += 1;
        boost::thread::sleep(xt);
        data.notified++;
        data.condition.notify_one();
        while (data.awoken != 1)
            data.condition.wait(lock);
        BOOST_CHECK_EQUAL(data.awoken, 1);
        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
        xt.sec += 1;
        boost::thread::sleep(xt);
        data.notified++;
        data.condition.notify_one();
        while (data.awoken != 2)
            data.condition.wait(lock);
        BOOST_CHECK_EQUAL(data.awoken, 2);
        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
        xt.sec += 1;
        boost::thread::sleep(xt);
        data.notified++;
        data.condition.notify_one();
        while (data.awoken != 3)
            data.condition.wait(lock);
        BOOST_CHECK_EQUAL(data.awoken, 3);
    }
    BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
    xt.sec += 1;
    boost::thread::sleep(xt);
    data.notified++;
    data.condition.notify_one();
    BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
    xt.sec += 1;
    boost::thread::sleep(xt);
    thread.join();
    BOOST_CHECK_EQUAL(data.awoken, 4);
 }
 boost::unit_test_framework::test_suite* condition_tests()
 {
 	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: condition test suite");
 	test->add(BOOST_TEST_CASE(&test_condition_notify_one));
 	test->add(BOOST_TEST_CASE(&test_condition_notify_all));
 	test->add(BOOST_TEST_CASE(&test_condition_waits));
 	return test;
 }
--- a/test/test_mutex.cpp
+++ b/test/test_mutex.cpp
@@ -0,0 +1,184 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/test/unit_test_suite_ex.hpp>
 template <typename M>
 struct test_lock
 {
 	typedef M mutex_type;
 	typedef typename M::scoped_lock lock_type;
 	void operator()()
 	{
 		mutex_type mutex;
 		boost::condition condition;
 		// Test the lock's constructors.
 		{
 			lock_type lock(mutex, false);
 			BOOST_CHECK(!lock);
 		}
 		lock_type lock(mutex);
 		BOOST_CHECK(lock);
 		// Construct and initialize an xtime for a fast time out.
 		boost::xtime xt;
 		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
 		xt.nsec += 100000000;
 		// Test the lock and the mutex with condition variables.
 		// No one is going to notify this condition variable.  We expect to
 		// time out.
 		BOOST_CHECK(!condition.timed_wait(lock, xt));
 		BOOST_CHECK(lock);
 		// Test the lock and unlock methods.
 		lock.unlock();
 		BOOST_CHECK(!lock);
 		lock.lock();
 		BOOST_CHECK(lock);
 	}
 };
 template <typename M>
 struct test_trylock
 {
    typedef M mutex_type;
    typedef typename M::scoped_try_lock try_lock_type;
 	void operator()()
 	{
 		mutex_type mutex;
 		boost::condition condition;
 		// Test the lock's constructors.
 		{
 			try_lock_type lock(mutex);
 			BOOST_CHECK(lock);
 		}
 		{
 			try_lock_type lock(mutex, false);
 			BOOST_CHECK(!lock);
 		}
 		try_lock_type lock(mutex, true);
 		BOOST_CHECK(lock);
 		// Construct and initialize an xtime for a fast time out.
 		boost::xtime xt;
 		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
 		xt.nsec += 100000000;
 		// Test the lock and the mutex with condition variables.
 		// No one is going to notify this condition variable.  We expect to
 		// time out.
 		BOOST_CHECK(!condition.timed_wait(lock, xt));
 		BOOST_CHECK(lock);
 		// Test the lock, unlock and trylock methods.
 		lock.unlock();
 		BOOST_CHECK(!lock);
 		lock.lock();
 		BOOST_CHECK(lock);
 		lock.unlock();
 		BOOST_CHECK(!lock);
 		BOOST_CHECK(lock.try_lock());
 		BOOST_CHECK(lock);
 	}
 };
 template <typename M>
 struct test_timedlock
 {
    typedef M mutex_type;
    typedef typename M::scoped_timed_lock timed_lock_type;
 	void operator()()
 	{
 		mutex_type mutex;
 		boost::condition condition;
 		// Test the lock's constructors.
 		{
 			// Construct and initialize an xtime for a fast time out.
 			boost::xtime xt;
 			BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
 			xt.nsec += 100000000;
 			timed_lock_type lock(mutex, xt);
 			BOOST_CHECK(lock);
 		}
 		{
 			timed_lock_type lock(mutex, false);
 			BOOST_CHECK(!lock);
 		}
 		timed_lock_type lock(mutex, true);
 		BOOST_CHECK(lock);
 		// Construct and initialize an xtime for a fast time out.
 		boost::xtime xt;
 		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
 		xt.nsec += 100000000;
 		// Test the lock and the mutex with condition variables.
 		// No one is going to notify this condition variable.  We expect to
 		// time out.
 		BOOST_CHECK(!condition.timed_wait(lock, xt));
 		BOOST_CHECK(lock);
 		// Test the lock, unlock and timedlock methods.
 		lock.unlock();
 		BOOST_CHECK(!lock);
 		lock.lock();
 		BOOST_CHECK(lock);
 		lock.unlock();
 		BOOST_CHECK(!lock);
 		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
 		xt.nsec += 100000000;
 		BOOST_CHECK(lock.timed_lock(xt));
 	}
 };
 template <typename M>
 struct test_recursive_lock
 {
 	typedef M mutex;
 	void operator()()
 	{
 		mutex mx;
 		mutex::scoped_lock lock1(mx);
 		mutex::scoped_lock lock2(mx);
 	}
 };
 boost::unit_test_framework::test_suite* mutex_tests()
 {
 	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: mutex test suite");
 	test->add(BOOST_TEST_CASE(test_lock<boost::mutex>()));
 	test->add(BOOST_TEST_CASE(test_lock<boost::try_mutex>()));
 	test->add(BOOST_TEST_CASE(test_trylock<boost::try_mutex>()));
 	test->add(BOOST_TEST_CASE(test_lock<boost::timed_mutex>()));
 	test->add(BOOST_TEST_CASE(test_trylock<boost::timed_mutex>()));
 	test->add(BOOST_TEST_CASE(test_timedlock<boost::timed_mutex>()));
 	test->add(BOOST_TEST_CASE(test_lock<boost::recursive_mutex>()));
 	test->add(BOOST_TEST_CASE(test_recursive_lock<boost::recursive_mutex>()));
 	test->add(BOOST_TEST_CASE(test_lock<boost::recursive_try_mutex>()));
 	test->add(BOOST_TEST_CASE(test_trylock<boost::recursive_try_mutex>()));
 	test->add(BOOST_TEST_CASE(test_recursive_lock<boost::recursive_try_mutex>()));
 	test->add(BOOST_TEST_CASE(test_lock<boost::recursive_timed_mutex>()));
 	test->add(BOOST_TEST_CASE(test_trylock<boost::recursive_timed_mutex>()));
 	test->add(BOOST_TEST_CASE(test_timedlock<boost::recursive_timed_mutex>()));
 	test->add(BOOST_TEST_CASE(test_recursive_lock<boost::recursive_timed_mutex>()));
 	return test;
 }
--- a/test/test_once.cpp
+++ b/test/test_once.cpp
@@ -0,0 +1,39 @@
 #include <boost/thread/once.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/test/unit_test.hpp>
 namespace
 {
 	int once_value = 0;
 	boost::once_flag once = BOOST_ONCE_INIT;
 	void init_once_value()
 	{
 		once_value++;
 	}
 	void test_once_thread()
 	{
 		boost::call_once(&init_once_value, once);
 	}
 }
 void test_once()
 {
 	const int NUMTHREADS=5;
 	boost::thread_group threads;
 	for (int i=0; i<NUMTHREADS; ++i)
 		threads.create_thread(&test_once_thread);
 	threads.join_all();
 	BOOST_CHECK_EQUAL(once_value, 1);
 }
 boost::unit_test_framework::test_suite* once_tests()
 {
 	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: once test suite");
 	test->add(BOOST_TEST_CASE(&test_once));
 	return test;
 }
--- a/test/test_thread.cpp
+++ b/test/test_thread.cpp
@@ -0,0 +1,89 @@
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/test/unit_test.hpp>
 namespace
 {
 	inline bool xtime_in_range(boost::xtime& xt, int less_seconds, int greater_seconds)
 	{
 		boost::xtime cur;
 		BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
 		boost::xtime less = cur;
 		less.sec += less_seconds;
 		boost::xtime greater = cur;
 		greater.sec += greater_seconds;
 		return (boost::xtime_cmp(xt, less) >= 0) && (boost::xtime_cmp(xt, greater) <= 0);
 	}
 	int test_value;
 	void simple_thread()
 	{
 		test_value = 999;
 	}
 	struct thread_adapter
 	{
 		thread_adapter(void (*func)(boost::thread& parent), boost::thread& parent)
 			: func(func), parent(parent)
 		{
 		}
 		void operator()()
 		{
 			(*func)(parent);
 		}
 		void (*func)(boost::thread& parent);
 		boost::thread& parent;
 	};
 	void comparison_thread(boost::thread& parent)
 	{
 		boost::thread thrd;
 		BOOST_TEST(thrd != parent);
 		BOOST_TEST(thrd == boost::thread());
 	}
 }
 void test_sleep()
 {
 	boost::xtime xt;
 	BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
 	xt.sec += 5;
 	boost::thread::sleep(xt);
 	// Insure it's in a range instead of checking actual equality due to time lapse
 	BOOST_CHECK(xtime_in_range(xt, -1, 1));
 }
 void test_creation()
 {
 	test_value = 0;
 	boost::thread thrd(&simple_thread);
 	thrd.join();
 	BOOST_CHECK_EQUAL(test_value, 999);
 }
 void test_comparison()
 {
 	boost::thread self;
 	boost::thread thrd(thread_adapter(&comparison_thread, self));
 	thrd.join();
 }
 boost::unit_test_framework::test_suite* thread_tests()
 {
 	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: thread test suite");
    test->add(BOOST_TEST_CASE(&test_sleep));
 	test->add(BOOST_TEST_CASE(&test_creation));
 	test->add(BOOST_TEST_CASE(&test_comparison));
    return test;
 }
--- a/test/test_tss.cpp
+++ b/test/test_tss.cpp
@@ -0,0 +1,59 @@
 #include <boost/thread/tss.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/test/unit_test.hpp>
 namespace
 {
 	boost::mutex tss_mutex;
 	int tss_instances = 0;
 	struct tss_value_t
 	{
 		tss_value_t()
 		{
 			boost::mutex::scoped_lock lock(tss_mutex);
 			++tss_instances;
 			value = 0;
 		}
 		~tss_value_t()
 		{
 			boost::mutex::scoped_lock lock(tss_mutex);
 			--tss_instances;
 		}
 		int value;
 	};
 	boost::thread_specific_ptr<tss_value_t> tss_value;
 	void test_tss_thread()
 	{
 		tss_value.reset(new tss_value_t());
 		for (int i=0; i<1000; ++i)
 		{
 			int& n = tss_value->value;
 			BOOST_CHECK_EQUAL(n, i);
 			++n;
 		}
 	}
 }
 void test_tss()
 {
    const int NUMTHREADS=5;
    boost::thread_group threads;
    for (int i=0; i<NUMTHREADS; ++i)
        threads.create_thread(&test_tss_thread);
    threads.join_all();
    BOOST_CHECK_EQUAL(tss_instances, 0);
 }
 boost::unit_test_framework::test_suite* tss_tests()
 {
 	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: tss test suite");
 	test->add(BOOST_TEST_CASE(&test_tss));
 	return test;
 }
Author	SHA1	Message	Date
nobody	f25e80b47c	This commit was manufactured by cvs2svn to create branch 'python-v2-dev'. [SVN r14785]	2002-08-12 13:35:54 +00:00
William E. Kempf	43cbd3a283	Split up tests into seperate files and switched fully to unit test framework [SVN r14780]	2002-08-12 05:43:10 +00:00
William E. Kempf	31cf6b5e64	Initial switch to Boost.Test unit test framework [SVN r14779]	2002-08-12 00:09:33 +00:00
Dave Abrahams	99109ab78b	respect <sysinclude> [SVN r13995]	2002-05-21 16:24:07 +00:00
William E. Kempf	a80d5f159d	Merged from RC_1_28_0 branch [SVN r13905]	2002-05-15 14:35:39 +00:00
William E. Kempf	7ba4fc4aed	Changed logic_error to runtime_error for thread_resource_error [SVN r13644]	2002-05-03 16:19:13 +00:00
William E. Kempf	9fb31e9868	Updated documentation for pending release [SVN r13606]	2002-05-01 15:37:25 +00:00
William E. Kempf	3a2246de5b	Fixed broken links [SVN r13570]	2002-04-26 21:15:40 +00:00
William E. Kempf	e7c4e2fa57	Removed boost/thread/config.hpp and changed Boost.Threads exceptions to derive from logic_error [SVN r13568]	2002-04-26 20:56:49 +00:00
William E. Kempf	724ab285f0	Updated the rest of the documentation to the new templates. [SVN r13567]	2002-04-26 20:41:25 +00:00
William E. Kempf	d60e66fb00	More Boost.Threads doc changes [SVN r13453]	2002-04-11 22:15:26 +00:00
William E. Kempf	97cdaca028	Boost.Threads documentation updates. [SVN r13439]	2002-04-10 22:08:15 +00:00
Dave Abrahams	3044c8f905	Bug fix [SVN r13341]	2002-04-01 20:13:43 +00:00
William E. Kempf	2775a2a945	Updated <runtime-link> info in Jamfile [SVN r13198]	2002-03-14 23:29:18 +00:00
William E. Kempf	c43c1febba	Fixed bug in example in mutex.html [SVN r13197]	2002-03-14 23:24:16 +00:00
William E. Kempf	ceb6471d57	Updated thread.html for new documentation style. [SVN r13196]	2002-03-14 23:23:48 +00:00
William E. Kempf	b99cc044f3	Updated Jamfile [SVN r13095]	2002-03-05 16:27:46 +00:00
Rene Rivera	d91429dcec	Moved the <runtime-link> to the build request. [SVN r13018]	2002-03-02 18:41:22 +00:00
William E. Kempf	b1d1f7d8f1	Jamfile modifications [SVN r13001]	2002-03-01 23:10:11 +00:00
Dave Abrahams	86b608cf41	Updates to work on Linux [SVN r12981]	2002-02-28 12:35:05 +00:00
Dave Abrahams	f263f75751	Killed bogus runtime-link specification [SVN r12946]	2002-02-27 02:11:12 +00:00
William E. Kempf	24bec05b86	Added .cvsignore and updated Jam stuff [SVN r12944]	2002-02-26 21:02:13 +00:00
William E. Kempf	ce1a5e9359	fixed missing } bug [SVN r12903]	2002-02-22 18:32:08 +00:00
William E. Kempf	311525bc06	replaced <dll>thread_mon with $(THREADMON_DLL) [SVN r12902]	2002-02-22 18:31:20 +00:00
William E. Kempf	ecdfd96529	fixed typename warnings [SVN r12901]	2002-02-22 18:30:34 +00:00
William E. Kempf	5aab32bc1a	More Jamfile changes. [SVN r12857]	2002-02-18 23:04:25 +00:00
William E. Kempf	e152a1c6f2	Updated Jamfiles for new Boost.Build system [SVN r12856]	2002-02-18 23:02:38 +00:00
Rene Rivera	e84fde78ec	Updated the basic Jamfiles for the new Boost.Build changes. [SVN r12798]	2002-02-14 04:08:20 +00:00
William E. Kempf	6ec4652bcf	Updated thread documentation to use new templates. [SVN r12785]	2002-02-11 23:13:04 +00:00
William E. Kempf	a5239c820b	Fixed tabs in files [SVN r12622]	2002-02-01 17:31:46 +00:00
William E. Kempf	41b001b22c	Removed warnings reported by gcc. [SVN r12492]	2002-01-24 19:17:36 +00:00
William E. Kempf	34e903b8b0	Fixed bug in example. [SVN r12489]	2002-01-24 19:13:19 +00:00
Mac Murrett	2b67e953fd	Changed prefix file to debug_prefix.hpp [SVN r12487]	2002-01-24 17:33:03 +00:00
Mac Murrett	aa0d3adf1d	* empty log message * [SVN r12486]	2002-01-24 17:26:13 +00:00
Mac Murrett	a1f57a8a80	* empty log message * [SVN r12485]	2002-01-24 17:19:44 +00:00
William E. Kempf	6bc82a8580	Added Mac Carbon implementation to Boost.Threads. [SVN r12480]	2002-01-24 16:32:23 +00:00
William E. Kempf	c4c2e5d3a2	Fixed bug in notify_one that caused deadlock. [SVN r12178]	2001-12-31 17:18:46 +00:00
Dave Abrahams	dd7d4b2173	Metrowerks needs BOOST_NO_STD_LOCALE in config to be able to compile regex regex test Jamfile updates so that some tests will actually run warning suppression for condition.cpp unit-test rule now accepts input files updated metrowerks and borland to properly set up path for running tests ---------------------------------------------------------------------- Modified Files: boost/config/compiler/metrowerks.hpp libs/python/src/gen_function.py libs/regex/test/Jamfile Tag: thread-initial libs/thread/src/condition.cpp No tag tools/build/boost-base.jam tools/build/borland-tools.jam tools/build/metrowerks-tools.jam ---------------------------------------------------------------------- [SVN r11853]	2001-12-02 17:43:45 +00:00
Beman Dawes	2719c4d545	Try to get the date stamps in sync [SVN r11618]	2001-11-07 00:37:59 +00:00
Beman Dawes	33c1e36b54	Add "Why has semaphore disappeared" FAQ [SVN r11586]	2001-11-05 15:42:10 +00:00
William E. Kempf	e7e46e185e	Fixed bug found compiling with gcc. [SVN r11584]	2001-11-05 15:13:57 +00:00
William E. Kempf	9200d48873	Added lock_ops<> detail concept. [SVN r11540]	2001-11-02 23:34:50 +00:00
William E. Kempf	831d054d24	Added exceptions.cpp. [SVN r11502]	2001-11-01 16:19:44 +00:00
William E. Kempf	f3af804ddb	Removed semaphores. Fixed some reported bugs. Switched to CRITICAL_SECTION implementations. [SVN r11501]	2001-11-01 16:18:57 +00:00
John Maddock	1f35149ef0	Added code to normalise timespec structures. [SVN r11500]	2001-11-01 12:56:57 +00:00
William E. Kempf	554a18842f	Switched to void* for HANDLE types. Changed boost::once_init to the macro BOOST_ONCE_INIT. [SVN r11475]	2001-10-30 22:12:37 +00:00
William E. Kempf	869243b6d1	Updated Jamfiles for PTW32, removed _atomic.cpp and added Win32 conditional compilation blocks for threadmon files. [SVN r11468]	2001-10-29 22:20:50 +00:00
William E. Kempf	c0da02326a	Fixed reported documentation bugs. [SVN r11462]	2001-10-29 16:58:17 +00:00
William E. Kempf	9b5f666fc5	Removed tabs and trailing white space. [SVN r11403]	2001-10-18 19:56:32 +00:00
William E. Kempf	1ce93426a4	Fixed Jamfile. [SVN r11396]	2001-10-16 22:10:45 +00:00
William E. Kempf	6dacf3478b	Fixed sprintf bugs in once.cpp. [SVN r11395]	2001-10-16 19:32:20 +00:00
William E. Kempf	dff91699c3	Fixed more warnings and errors found when compiling with gcc. [SVN r11388]	2001-10-15 21:28:11 +00:00
William E. Kempf	9f83e8c1fc	Modified Jamfile to allow for building using pthreads-win32 (code is commented out). [SVN r11387]	2001-10-15 18:34:01 +00:00
William E. Kempf	7b07cb0759	Fixed errors and warnings for gcc. Still some outstanding issues for gcc on Win32. [SVN r11386]	2001-10-15 18:32:21 +00:00
William E. Kempf	c2e7091632	Fixed reported warnings. Fixed once bug with void* and function pointer conversion. [SVN r11385]	2001-10-15 00:48:51 +00:00
Beman Dawes	1ab320042e	Minor typo fix and wording improvements [SVN r11365]	2001-10-08 20:20:07 +00:00
William E. Kempf	b0cd307eaf	Ran "tidy" against documentation. [SVN r11329]	2001-10-02 16:13:25 +00:00
Beman Dawes	ca2cf20cf3	1.25.0 Final runup [SVN r11315]	2001-10-01 15:54:23 +00:00
Beman Dawes	b3acba1d2d	commit after merging thread-initial into main trunk [SVN r11258]	2001-09-25 19:20:11 +00:00
Beman Dawes	6d2731c463	commit after merging thread-initial into main trunk [SVN r11250]	2001-09-25 16:57:26 +00:00
Beman Dawes	b7f8f8867c	merge branch "thread-initial" into main trunk [SVN r11243]	2001-09-25 00:04:45 +00:00