Release 1.29.0 beta 1

[SVN r52601]

CMakeLists.txt

@@ -0,0 +1,22 @@
+#----------------------------------------------------------------------------
+# This file was automatically generated from the original CMakeLists.txt file
+# Add a variable to hold the headers for the library
+set (lib_headers
+    thread.hpp
+    thread
+)
+
+# Add a library target to the build system
+boost_library_project(
+  thread
+  SRCDIRS  src 
+  TESTDIRS  test
+  HEADERS ${lib_headers}
+  #  DOCDIRS 
+  #  DESCRIPTION 
+  MODULARIZED 
+  #  AUTHORS 
+  #  MAINTAINERS 
+)
+
+

doc/Jamfile.v2

@@ -31,25 +31,6 @@ boostbook standalone
         # Use the main Boost stylesheet:
         <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
         
-        # PDF Options:
-        # TOC Generation: this is needed for FOP-0.9 and later:
-        #<xsl:param>fop1.extensions=1
-        # Or enable this if you're using XEP:
-        <xsl:param>xep.extensions=1
-        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
-        <xsl:param>fop.extensions=0
-        # No indent on body text:
-        <xsl:param>body.start.indent=0pt
-        # Margin size:
-        <xsl:param>page.margin.inner=0.5in
-        # Margin size:
-        <xsl:param>page.margin.outer=0.5in
-        # Yes, we want graphics for admonishments:
-        <xsl:param>admon.graphics=1
-        # Set this one for PDF generation *only*:
-        # default pnd graphics are awful in PDF form,
-        # better use SVG's instead:
-        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
-        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
     ;
 
+

module.cmake

@@ -0,0 +1 @@
+boost_module(thread DEPENDS date_time bind optional range)

src/CMakeLists.txt

@@ -0,0 +1,15 @@
+if (WIN32)
+  set(THREAD_SOURCES win32/thread.cpp win32/exceptions.cpp win32/tss_dll.cpp
+                     win32/tss_pe.cpp)
+else (WIN32)
+  set(THREAD_SOURCES pthread/thread.cpp pthread/exceptions.cpp pthread/once.cpp)
+endif (WIN32)
+
+boost_add_library(
+  boost_thread
+  ${THREAD_SOURCES}
+  SHARED_COMPILE_FLAGS "-DBOOST_THREAD_BUILD_DLL=1"
+  STATIC_COMPILE_FLAGS "-DBOOST_THREAD_BUILD_LIB=1"
+  NO_SINGLE_THREADED
+  )
+

src/pthread/thread.cpp

@@ -132,10 +132,12 @@ namespace boost
                 catch(thread_interrupted const&)
                 {
                 }
-                catch(...)
-                {
-                    std::terminate();
-                }
+// Removed as it stops the debugger identifying the cause of the exception
+// Unhandled exceptions still cause the application to terminate
+//                 catch(...)
+//                 {
+//                     std::terminate();
+//                 }
 
                 detail::tls_destructor(thread_info.get());
                 detail::set_current_thread_data(0);

src/win32/thread.cpp

@@ -169,10 +169,12 @@ namespace boost
             catch(thread_interrupted const&)
             {
             }
-            catch(...)
-            {
-                std::terminate();
-            }
+// Removed as it stops the debugger identifying the cause of the exception
+// Unhandled exceptions still cause the application to terminate
+//             catch(...)
+//             {
+//                 std::terminate();
+//             }
             run_thread_exit_callbacks();
             return 0;
         }

test/CMakeLists.txt

@@ -0,0 +1,33 @@
+boost_additional_test_dependencies(thread BOOST_DEPENDS test )
+
+
+
+set(TESTS 
+test_thread
+test_thread_id
+test_hardware_concurrency
+test_thread_move
+test_thread_launching
+test_thread_mf
+test_move_function
+test_mutex
+test_condition_notify_one
+test_condition_timed_wait_times_out
+test_condition_notify_all
+test_condition
+test_tss
+test_once
+test_xtime
+test_barrier
+test_shared_mutex
+test_shared_mutex_part_2
+test_shared_mutex_timed_locks
+test_lock_concept
+test_generic_locks)
+
+foreach (TEST ${TESTS})
+  boost_test_run(${TEST} MULTI_THREADED DEPENDS boost_thread boost_unit_test_framework)
+endforeach (TEST ${TESTS})
+
+boost_test_compile_fail(no_implicit_move_from_lvalue_thread)
+boost_test_compile_fail(no_implicit_assign_from_lvalue_thread)

test/util.inl

@@ -1,183 +1,183 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-// Copyright (C) 2007-8 Anthony Williams
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#if !defined(UTIL_INL_WEK01242003)
-#define UTIL_INL_WEK01242003
-
-#include <boost/thread/xtime.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition.hpp>
-#include <boost/thread/thread.hpp>
-
-#ifndef DEFAULT_EXECUTION_MONITOR_TYPE
-#   define DEFAULT_EXECUTION_MONITOR_TYPE execution_monitor::use_condition
-#endif
-
-// boostinspect:nounnamed
-
-namespace
-{
-inline boost::xtime delay(int secs, int msecs=0, int nsecs=0)
-{
-    const int MILLISECONDS_PER_SECOND = 1000;
-    const int NANOSECONDS_PER_SECOND = 1000000000;
-    const int NANOSECONDS_PER_MILLISECOND = 1000000;
-
-    boost::xtime xt;
-    if (boost::TIME_UTC != boost::xtime_get (&xt, boost::TIME_UTC))
-        BOOST_ERROR ("boost::xtime_get != boost::TIME_UTC");
-
-    nsecs += xt.nsec;
-    msecs += nsecs / NANOSECONDS_PER_MILLISECOND;
-    secs += msecs / MILLISECONDS_PER_SECOND;
-    nsecs += (msecs % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
-    xt.nsec = nsecs % NANOSECONDS_PER_SECOND;
-    xt.sec += secs + (nsecs / NANOSECONDS_PER_SECOND);
-
-    return xt;
-}
-
-inline bool in_range(const boost::xtime& xt, int secs=1)
-{
-    boost::xtime min = delay(-secs);
-    boost::xtime max = delay(0);
-    return (boost::xtime_cmp(xt, min) >= 0) &&
-        (boost::xtime_cmp(xt, max) <= 0);
-}
-
-class execution_monitor
-{
-public:
-    enum wait_type { use_sleep_only, use_mutex, use_condition };
-
-    execution_monitor(wait_type type, int secs)
-        : done(false), type(type), secs(secs) { }
-    void start()
-    {
-        if (type != use_sleep_only) {
-            boost::mutex::scoped_lock lock(mutex); done = false;
-        } else {
-            done = false;
-        }
-    }
-    void finish()
-    {
-        if (type != use_sleep_only) {
-            boost::mutex::scoped_lock lock(mutex);
-            done = true;
-            if (type == use_condition)
-                cond.notify_one();
-        } else {
-            done = true;
-        }
-    }
-    bool wait()
-    {
-        boost::xtime xt = delay(secs);
-        if (type != use_condition)
-            boost::thread::sleep(xt);
-        if (type != use_sleep_only) {
-            boost::mutex::scoped_lock lock(mutex);
-            while (type == use_condition && !done) {
-                if (!cond.timed_wait(lock, xt))
-                    break;
-            }
-            return done;
-        }
-        return done;
-    }
-
-private:
-    boost::mutex mutex;
-    boost::condition cond;
-    bool done;
-    wait_type type;
-    int secs;
-};
-
-template <typename F>
-class indirect_adapter
-{
-public:
-    indirect_adapter(F func, execution_monitor& monitor)
-        : func(func), monitor(monitor) { }
-    void operator()() const
-    {
-        try
-        {
-            boost::thread thrd(func);
-            thrd.join();
-        }
-        catch (...)
-        {
-            monitor.finish();
-            throw;
-        }
-        monitor.finish();
-    }
-
-private:
-    F func;
-    execution_monitor& monitor;
-    void operator=(indirect_adapter&);
-};
-
-template <typename F>
-void timed_test(F func, int secs,
-    execution_monitor::wait_type type=DEFAULT_EXECUTION_MONITOR_TYPE)
-{
-    execution_monitor monitor(type, secs);
-    indirect_adapter<F> ifunc(func, monitor);
-    monitor.start();
-    boost::thread thrd(ifunc);
-    BOOST_REQUIRE_MESSAGE(monitor.wait(),
-        "Timed test didn't complete in time, possible deadlock.");
-}
-
-template <typename F, typename T>
-class thread_binder
-{
-public:
-    thread_binder(const F& func, const T& param)
-        : func(func), param(param) { }
-    void operator()() const { func(param); }
-
-private:
-    F func;
-    T param;
-};
-
-template <typename F, typename T>
-thread_binder<F, T> bind(const F& func, const T& param)
-{
-    return thread_binder<F, T>(func, param);
-}
-
-template <typename R, typename T>
-class thread_member_binder
-{
-public:
-    thread_member_binder(R (T::*func)(), T& param)
-        : func(func), param(param) { }
-    void operator()() const { (param.*func)(); }
-
-private:
-    void operator=(thread_member_binder&);
-    
-    R (T::*func)();
-    T& param;
-};
-
-
-template <typename R, typename T>
-thread_member_binder<R, T> bind(R (T::*func)(), T& param)
-{
-    return thread_member_binder<R, T>(func, param);
-}
-} // namespace
-
-#endif
+// Copyright (C) 2001-2003
+// William E. Kempf
+// Copyright (C) 2007-8 Anthony Williams
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(UTIL_INL_WEK01242003)
+#define UTIL_INL_WEK01242003
+
+#include <boost/thread/xtime.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
+
+#ifndef DEFAULT_EXECUTION_MONITOR_TYPE
+#   define DEFAULT_EXECUTION_MONITOR_TYPE execution_monitor::use_condition
+#endif
+
+// boostinspect:nounnamed
+
+namespace
+{
+inline boost::xtime delay(int secs, int msecs=0, int nsecs=0)
+{
+    const int MILLISECONDS_PER_SECOND = 1000;
+    const int NANOSECONDS_PER_SECOND = 1000000000;
+    const int NANOSECONDS_PER_MILLISECOND = 1000000;
+
+    boost::xtime xt;
+    if (boost::TIME_UTC != boost::xtime_get (&xt, boost::TIME_UTC))
+        BOOST_ERROR ("boost::xtime_get != boost::TIME_UTC");
+
+    nsecs += xt.nsec;
+    msecs += nsecs / NANOSECONDS_PER_MILLISECOND;
+    secs += msecs / MILLISECONDS_PER_SECOND;
+    nsecs += (msecs % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
+    xt.nsec = nsecs % NANOSECONDS_PER_SECOND;
+    xt.sec += secs + (nsecs / NANOSECONDS_PER_SECOND);
+
+    return xt;
+}
+
+inline bool in_range(const boost::xtime& xt, int secs=1)
+{
+    boost::xtime min = delay(-secs);
+    boost::xtime max = delay(0);
+    return (boost::xtime_cmp(xt, min) >= 0) &&
+        (boost::xtime_cmp(xt, max) <= 0);
+}
+
+class execution_monitor
+{
+public:
+    enum wait_type { use_sleep_only, use_mutex, use_condition };
+
+    execution_monitor(wait_type type, int secs)
+        : done(false), type(type), secs(secs) { }
+    void start()
+    {
+        if (type != use_sleep_only) {
+            boost::mutex::scoped_lock lock(mutex); done = false;
+        } else {
+            done = false;
+        }
+    }
+    void finish()
+    {
+        if (type != use_sleep_only) {
+            boost::mutex::scoped_lock lock(mutex);
+            done = true;
+            if (type == use_condition)
+                cond.notify_one();
+        } else {
+            done = true;
+        }
+    }
+    bool wait()
+    {
+        boost::xtime xt = delay(secs);
+        if (type != use_condition)
+            boost::thread::sleep(xt);
+        if (type != use_sleep_only) {
+            boost::mutex::scoped_lock lock(mutex);
+            while (type == use_condition && !done) {
+                if (!cond.timed_wait(lock, xt))
+                    break;
+            }
+            return done;
+        }
+        return done;
+    }
+
+private:
+    boost::mutex mutex;
+    boost::condition cond;
+    bool done;
+    wait_type type;
+    int secs;
+};
+
+template <typename F>
+class indirect_adapter
+{
+public:
+    indirect_adapter(F func, execution_monitor& monitor)
+        : func(func), monitor(monitor) { }
+    void operator()() const
+    {
+        try
+        {
+            boost::thread thrd(func);
+            thrd.join();
+        }
+        catch (...)
+        {
+            monitor.finish();
+            throw;
+        }
+        monitor.finish();
+    }
+
+private:
+    F func;
+    execution_monitor& monitor;
+    void operator=(indirect_adapter&);
+};
+
+template <typename F>
+void timed_test(F func, int secs,
+    execution_monitor::wait_type type=DEFAULT_EXECUTION_MONITOR_TYPE)
+{
+    execution_monitor monitor(type, secs);
+    indirect_adapter<F> ifunc(func, monitor);
+    monitor.start();
+    boost::thread thrd(ifunc);
+    BOOST_REQUIRE_MESSAGE(monitor.wait(),
+        "Timed test didn't complete in time, possible deadlock.");
+}
+
+template <typename F, typename T>
+class thread_binder
+{
+public:
+    thread_binder(const F& func, const T& param)
+        : func(func), param(param) { }
+    void operator()() const { func(param); }
+
+private:
+    F func;
+    T param;
+};
+
+template <typename F, typename T>
+thread_binder<F, T> bind(const F& func, const T& param)
+{
+    return thread_binder<F, T>(func, param);
+}
+
+template <typename R, typename T>
+class thread_member_binder
+{
+public:
+    thread_member_binder(R (T::*func)(), T& param)
+        : func(func), param(param) { }
+    void operator()() const { (param.*func)(); }
+
+private:
+    void operator=(thread_member_binder&);
+    
+    R (T::*func)();
+    T& param;
+};
+
+
+template <typename R, typename T>
+thread_member_binder<R, T> bind(R (T::*func)(), T& param)
+{
+    return thread_member_binder<R, T>(func, param);
+}
+} // namespace
+
+#endif