1.36.0

[SVN r48100]

CMakeLists.txt

@@ -1,28 +0,0 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-#----------------------------------------------------------------------------
-# 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,6 +31,25 @@ 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)/
     ;
 
-

doc/changes.qbk

@@ -77,7 +77,4 @@ been moved to __thread_id__.
 
 * __mutex__ is now never recursive. For Boost releases prior to 1.35 __mutex__ was recursive on Windows and not on POSIX platforms.
 
-* When using a __recursive_mutex__ with a call to [cond_any_wait_link `boost::condition_variable_any::wait()`], the mutex is only
-  unlocked one level, and not completely. This prior behaviour was not guaranteed and did not feature in the tests.
-
 [endsect]

example/condition.cpp

@@ -50,9 +50,8 @@ boost::mutex io_mutex;
 
 void sender() {
     int n = 0;
-    while (n < 1000000) {
+    while (n < 100) {
         buf.send(n);
-        if(!(n%10000))
         {
             boost::mutex::scoped_lock io_lock(io_mutex);
             std::cout << "sent: " << n << std::endl;
@@ -66,24 +65,18 @@ void receiver() {
     int n;
     do {
         n = buf.receive();
-        if(!(n%10000))
         {
             boost::mutex::scoped_lock io_lock(io_mutex);
             std::cout << "received: " << n << std::endl;
         }
     } while (n != -1); // -1 indicates end of buffer
-    buf.send(-1);
 }
 
 int main(int, char*[])
 {
     boost::thread thrd1(&sender);
     boost::thread thrd2(&receiver);
-    boost::thread thrd3(&receiver);
-    boost::thread thrd4(&receiver);
     thrd1.join();
     thrd2.join();
-    thrd3.join();
-    thrd4.join();
     return 0;
 }

example/tennis.cpp

@@ -112,7 +112,7 @@ int main(int argc, char* argv[])
         std::cout << "---Noise ON..." << std::endl;
     }
 
-    for (int i = 0; i < 1000000000; ++i)
+    for (int i = 0; i < 1000000; ++i)
         cond.notify_all();
 
     {

include/boost/thread/detail/move.hpp

@@ -43,7 +43,7 @@ namespace boost
     template<typename T>
     typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, detail::thread_move_t<T> >::type move(T& t)
     {
-        return detail::thread_move_t<T>(t);
+        return t;
     }
 #endif
     

include/boost/thread/detail/thread.hpp

@@ -144,9 +144,6 @@ namespace boost
         struct dummy;
 #endif
     public:
-#ifdef __SUNPRO_CC 
-        thread(const volatile thread&); 
-#endif 
         thread();
         ~thread();
 
@@ -204,21 +201,14 @@ namespace boost
             thread_info=x->thread_info;
             x->thread_info.reset();
         }
-       
-#ifdef __SUNPRO_CC 
-        thread& operator=(thread x) 
-        { 
-            swap(x); 
-            return *this; 
-        } 
-#else
+        
         thread& operator=(detail::thread_move_t<thread> x)
         {
             thread new_thread(x);
             swap(new_thread);
             return *this;
         }
-#endif   
+        
         operator detail::thread_move_t<thread>()
         {
             return move();

include/boost/thread/locks.hpp

@@ -214,9 +214,6 @@ namespace boost
         unique_lock& operator=(unique_lock&);
         unique_lock& operator=(upgrade_lock<Mutex>& other);
     public:
-#ifdef __SUNPRO_CC 
-        unique_lock(const volatile unique_lock&); 
-#endif
         unique_lock():
             m(0),is_locked(false)
         {}
@@ -237,12 +234,6 @@ namespace boost
         {
             try_lock();
         }
-        template<typename TimeDuration>
-        unique_lock(Mutex& m_,TimeDuration const& target_time):
-            m(&m_),is_locked(false)
-        {
-            timed_lock(target_time);
-        }
         unique_lock(Mutex& m_,system_time const& target_time):
             m(&m_),is_locked(false)
         {
@@ -300,20 +291,12 @@ namespace boost
             return detail::thread_move_t<unique_lock<Mutex> >(*this);
         }
 
-#ifdef __SUNPRO_CC
-        unique_lock& operator=(unique_lock<Mutex> other) 
-        { 
-            swap(other); 
-            return *this; 
-        } 
-#else
         unique_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
         {
             unique_lock temp(other);
             swap(temp);
             return *this;
         }
-#endif
 
         unique_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
         {

include/boost/thread/pthread/recursive_mutex.hpp

@@ -177,7 +177,7 @@ namespace boost
         {
             struct timespec const timeout=detail::get_timespec(abs_time);
             int const res=pthread_mutex_timedlock(&m,&timeout);
-            BOOST_ASSERT(!res || res==ETIMEDOUT);
+            BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }
 

include/boost/thread/pthread/shared_mutex.hpp

@@ -57,18 +57,18 @@ namespace boost
         void lock_shared()
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             while(state.exclusive || state.exclusive_waiting_blocked)
             {
-                shared_cond.wait(lk);
+                shared_cond.wait(lock);
             }
             ++state.shared_count;
         }
 
         bool try_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             if(state.exclusive || state.exclusive_waiting_blocked)
             {
@@ -84,11 +84,11 @@ namespace boost
         bool timed_lock_shared(system_time const& timeout)
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             while(state.exclusive || state.exclusive_waiting_blocked)
             {
-                if(!shared_cond.timed_wait(lk,timeout))
+                if(!shared_cond.timed_wait(lock,timeout))
                 {
                     return false;
                 }
@@ -105,7 +105,7 @@ namespace boost
 
         void unlock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             bool const last_reader=!--state.shared_count;
                 
             if(last_reader)
@@ -127,12 +127,12 @@ namespace boost
         void lock()
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             while(state.shared_count || state.exclusive)
             {
                 state.exclusive_waiting_blocked=true;
-                exclusive_cond.wait(lk);
+                exclusive_cond.wait(lock);
             }
             state.exclusive=true;
         }
@@ -140,12 +140,12 @@ namespace boost
         bool timed_lock(system_time const& timeout)
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
 
             while(state.shared_count || state.exclusive)
             {
                 state.exclusive_waiting_blocked=true;
-                if(!exclusive_cond.timed_wait(lk,timeout))
+                if(!exclusive_cond.timed_wait(lock,timeout))
                 {
                     if(state.shared_count || state.exclusive)
                     {
@@ -168,7 +168,7 @@ namespace boost
 
         bool try_lock()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
                 
             if(state.shared_count || state.exclusive)
             {
@@ -184,7 +184,7 @@ namespace boost
 
         void unlock()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.exclusive=false;
             state.exclusive_waiting_blocked=false;
             release_waiters();
@@ -193,10 +193,10 @@ namespace boost
         void lock_upgrade()
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
-                shared_cond.wait(lk);
+                shared_cond.wait(lock);
             }
             ++state.shared_count;
             state.upgrade=true;
@@ -205,10 +205,10 @@ namespace boost
         bool timed_lock_upgrade(system_time const& timeout)
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
-                if(!shared_cond.timed_wait(lk,timeout))
+                if(!shared_cond.timed_wait(lock,timeout))
                 {
                     if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
                     {
@@ -230,7 +230,7 @@ namespace boost
 
         bool try_lock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
                 return false;
@@ -245,7 +245,7 @@ namespace boost
 
         void unlock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.upgrade=false;
             bool const last_reader=!--state.shared_count;
                 
@@ -259,11 +259,11 @@ namespace boost
         void unlock_upgrade_and_lock()
         {
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             --state.shared_count;
             while(state.shared_count)
             {
-                upgrade_cond.wait(lk);
+                upgrade_cond.wait(lock);
             }
             state.upgrade=false;
             state.exclusive=true;
@@ -271,7 +271,7 @@ namespace boost
 
         void unlock_and_lock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.exclusive=false;
             state.upgrade=true;
             ++state.shared_count;
@@ -281,7 +281,7 @@ namespace boost
         
         void unlock_and_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.exclusive=false;
             ++state.shared_count;
             state.exclusive_waiting_blocked=false;
@@ -290,7 +290,7 @@ namespace boost
         
         void unlock_upgrade_and_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::mutex::scoped_lock lock(state_change);
             state.upgrade=false;
             state.exclusive_waiting_blocked=false;
             release_waiters();

include/boost/thread/pthread/thread_data.hpp

@@ -13,7 +13,6 @@
 #include <boost/optional.hpp>
 #include <pthread.h>
 #include "condition_variable_fwd.hpp"
-#include <map>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -23,18 +22,8 @@ namespace boost
     
     namespace detail
     {
-        struct tss_cleanup_function;
         struct thread_exit_callback_node;
-        struct tss_data_node
-        {
-            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
-            void* value;
-
-            tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
-                          void* value_):
-                func(func_),value(value_)
-            {}
-        };
+        struct tss_data_node;
 
         struct thread_data_base;
         typedef boost::shared_ptr<thread_data_base> thread_data_ptr;
@@ -52,14 +41,14 @@ namespace boost
             bool join_started;
             bool joined;
             boost::detail::thread_exit_callback_node* thread_exit_callbacks;
-            std::map<void const*,boost::detail::tss_data_node> tss_data;
+            boost::detail::tss_data_node* tss_data;
             bool interrupt_enabled;
             bool interrupt_requested;
             pthread_cond_t* current_cond;
 
             thread_data_base():
                 done(false),join_started(false),joined(false),
-                thread_exit_callbacks(0),
+                thread_exit_callbacks(0),tss_data(0),
                 interrupt_enabled(true),
                 interrupt_requested(false),
                 current_cond(0)

include/boost/thread/tss.hpp

@@ -1,111 +1,111 @@
-#ifndef BOOST_THREAD_TSS_HPP
-#define BOOST_THREAD_TSS_HPP
-// 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)
-// (C) Copyright 2007-8 Anthony Williams
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/thread/detail/thread_heap_alloc.hpp>
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-    namespace detail
-    {
-        struct tss_cleanup_function
-        {
-            virtual ~tss_cleanup_function()
-            {}
-            
-            virtual void operator()(void* data)=0;
-        };
-        
-        BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
-        BOOST_THREAD_DECL void* get_tss_data(void const* key);
-    }
-
-    template <typename T>
-    class thread_specific_ptr
-    {
-    private:
-        thread_specific_ptr(thread_specific_ptr&);
-        thread_specific_ptr& operator=(thread_specific_ptr&);
-
-        struct delete_data:
-            detail::tss_cleanup_function
-        {
-            void operator()(void* data)
-            {
-                delete static_cast<T*>(data);
-            }
-        };
-        
-        struct run_custom_cleanup_function:
-            detail::tss_cleanup_function
-        {
-            void (*cleanup_function)(T*);
-            
-            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
-                cleanup_function(cleanup_function_)
-            {}
-            
-            void operator()(void* data)
-            {
-                cleanup_function(static_cast<T*>(data));
-            }
-        };
-
-
-        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
-        
-    public:
-        thread_specific_ptr():
-            cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
-        {}
-        explicit thread_specific_ptr(void (*func_)(T*))
-        {
-            if(func_)
-            {
-                cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
-            }
-        }
-        ~thread_specific_ptr()
-        {
-            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,true);
-        }
-
-        T* get() const
-        {
-            return static_cast<T*>(detail::get_tss_data(this));
-        }
-        T* operator->() const
-        {
-            return get();
-        }
-        T& operator*() const
-        {
-            return *get();
-        }
-        T* release()
-        {
-            T* const temp=get();
-            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
-            return temp;
-        }
-        void reset(T* new_value=0)
-        {
-            T* const current_value=get();
-            if(current_value!=new_value)
-            {
-                detail::set_tss_data(this,cleanup,new_value,true);
-            }
-        }
-    };
-}
-
-#include <boost/config/abi_suffix.hpp>
-
-#endif
+#ifndef BOOST_THREAD_TSS_HPP
+#define BOOST_THREAD_TSS_HPP
+// 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)
+// (C) Copyright 2007-8 Anthony Williams
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread/detail/thread_heap_alloc.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        struct tss_cleanup_function
+        {
+            virtual ~tss_cleanup_function()
+            {}
+            
+            virtual void operator()(void* data)=0;
+        };
+        
+        BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
+        BOOST_THREAD_DECL void* get_tss_data(void const* key);
+    }
+
+    template <typename T>
+    class thread_specific_ptr
+    {
+    private:
+        thread_specific_ptr(thread_specific_ptr&);
+        thread_specific_ptr& operator=(thread_specific_ptr&);
+
+        struct delete_data:
+            detail::tss_cleanup_function
+        {
+            void operator()(void* data)
+            {
+                delete static_cast<T*>(data);
+            }
+        };
+        
+        struct run_custom_cleanup_function:
+            detail::tss_cleanup_function
+        {
+            void (*cleanup_function)(T*);
+            
+            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
+                cleanup_function(cleanup_function_)
+            {}
+            
+            void operator()(void* data)
+            {
+                cleanup_function(static_cast<T*>(data));
+            }
+        };
+
+
+        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
+        
+    public:
+        thread_specific_ptr():
+            cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
+        {}
+        explicit thread_specific_ptr(void (*func_)(T*))
+        {
+            if(func_)
+            {
+                cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
+            }
+        }
+        ~thread_specific_ptr()
+        {
+            reset();
+        }
+
+        T* get() const
+        {
+            return static_cast<T*>(detail::get_tss_data(this));
+        }
+        T* operator->() const
+        {
+            return get();
+        }
+        T& operator*() const
+        {
+            return *get();
+        }
+        T* release()
+        {
+            T* const temp=get();
+            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
+            return temp;
+        }
+        void reset(T* new_value=0)
+        {
+            T* const current_value=get();
+            if(current_value!=new_value)
+            {
+                detail::set_tss_data(this,cleanup,new_value,true);
+            }
+        }
+    };
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif

include/boost/thread/win32/basic_recursive_mutex.hpp

@@ -64,6 +64,11 @@ namespace boost
                 return timed_lock(get_system_time()+timeout);
             }
 
+            long get_active_count()
+            {
+                return mutex.get_active_count();
+            }
+
             void unlock()
             {
                 if(!--recursion_count)
@@ -73,6 +78,11 @@ namespace boost
                 }
             }
 
+            bool locked()
+            {
+                return mutex.locked();
+            }
+            
         private:
             bool try_recursive_lock(long current_thread_id)
             {

include/boost/thread/win32/basic_timed_mutex.hpp

@@ -123,6 +123,11 @@ namespace boost
                 return timed_lock(system_time(timeout));
             }
 
+            long get_active_count()
+            {
+                return ::boost::detail::interlocked_read_acquire(&active_count);
+            }
+
             void unlock()
             {
                 long const offset=lock_flag_value;
@@ -136,6 +141,11 @@ namespace boost
                 }
             }
 
+            bool locked()
+            {
+                return get_active_count()>=lock_flag_value;
+            }
+            
         private:
             void* get_event()
             {

module.cmake

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

src/CMakeLists.txt

@@ -1,21 +0,0 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-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

@@ -42,6 +42,19 @@ namespace boost
             {}
         };
 
+        struct tss_data_node
+        {
+            void const* key;
+            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
+            void* value;
+            tss_data_node* next;
+
+            tss_data_node(void const* key_,boost::shared_ptr<boost::detail::tss_cleanup_function> func_,void* value_,
+                          tss_data_node* next_):
+                key(key_),func(func_),value(value_),next(next_)
+            {}
+        };
+
         namespace
         {
             boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
@@ -54,7 +67,7 @@ namespace boost
                     boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
                     if(thread_info)
                     {
-                        while(!thread_info->tss_data.empty() || thread_info->thread_exit_callbacks)
+                        while(thread_info->tss_data || thread_info->thread_exit_callbacks)
                         {
                             while(thread_info->thread_exit_callbacks)
                             {
@@ -67,18 +80,15 @@ namespace boost
                                 }
                                 delete current_node;
                             }
-                            for(std::map<void const*,tss_data_node>::iterator next=thread_info->tss_data.begin(),
-                                    current,
-                                    end=thread_info->tss_data.end();
-                                next!=end;)
+                            while(thread_info->tss_data)
                             {
-                                current=next;
-                                ++next;
-                                if(current->second.func && current->second.value)
+                                detail::tss_data_node* const current_node=thread_info->tss_data;
+                                thread_info->tss_data=current_node->next;
+                                if(current_node->func)
                                 {
-                                    (*current->second.func)(current->second.value);
+                                    (*current_node->func)(current_node->value);
                                 }
-                                thread_info->tss_data.erase(current);
+                                delete current_node;
                             }
                         }
                         thread_info->self.reset();
@@ -122,12 +132,10 @@ namespace boost
                 catch(thread_interrupted const&)
                 {
                 }
-// Removed as it stops the debugger identifying the cause of the exception
-// Unhandled exceptions still cause the application to terminate
-//                 catch(...)
-//                 {
-//                     std::terminate();
-//                 }
+                catch(...)
+                {
+                    std::terminate();
+                }
 
                 detail::tls_destructor(thread_info.get());
                 detail::set_current_thread_data(0);
@@ -380,7 +388,7 @@ namespace boost
     {
 #if defined(PTW32_VERSION) || defined(__hpux)
         return pthread_num_processors_np();
-#elif defined(_GNU_SOURCE)
+#elif defined(__linux__)
         return get_nprocs();
 #elif defined(__APPLE__) || defined(__FreeBSD__)
         int count;
@@ -542,11 +550,14 @@ namespace boost
             detail::thread_data_base* const current_thread_data(get_current_thread_data());
             if(current_thread_data)
             {
-                std::map<void const*,tss_data_node>::iterator current_node=
-                    current_thread_data->tss_data.find(key);
-                if(current_node!=current_thread_data->tss_data.end())
+                detail::tss_data_node* current_node=current_thread_data->tss_data;
+                while(current_node)
                 {
-                    return &current_node->second;
+                    if(current_node->key==key)
+                    {
+                        return current_node;
+                    }
+                    current_node=current_node->next;
                 }
             }
             return NULL;
@@ -560,47 +571,106 @@ namespace boost
             }
             return NULL;
         }
-
-        void add_new_tss_node(void const* key,
-                              boost::shared_ptr<tss_cleanup_function> func,
-                              void* tss_data)
-        {
-            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(func,tss_data)));
-        }
-
-        void erase_tss_node(void const* key)
-        {
-            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-            current_thread_data->tss_data.erase(key);
-        }
         
-        void set_tss_data(void const* key,
-                          boost::shared_ptr<tss_cleanup_function> func,
-                          void* tss_data,bool cleanup_existing)
+        void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing)
         {
             if(tss_data_node* const current_node=find_tss_data(key))
             {
-                if(cleanup_existing && current_node->func && current_node->value)
+                if(cleanup_existing && current_node->func)
                 {
                     (*current_node->func)(current_node->value);
                 }
-                if(func || tss_data)
-                {
-                    current_node->func=func;
-                    current_node->value=tss_data;
-                }
-                else
-                {
-                    erase_tss_node(key);
-                }
+                current_node->func=func;
+                current_node->value=tss_data;
             }
             else
             {
-                add_new_tss_node(key,func,tss_data);
+                detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
+                tss_data_node* const new_node=new tss_data_node(key,func,tss_data,current_thread_data->tss_data);
+                current_thread_data->tss_data=new_node;
             }
         }
     }
 
+//     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);
+//         BOOST_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);
+//         BOOST_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();
+//         }
+//     }
+
+//     void thread_group::interrupt_all()
+//     {
+//         boost::lock_guard<mutex> guard(m_mutex);
+            
+//         for(std::list<thread*>::iterator it=m_threads.begin(),end=m_threads.end();
+//             it!=end;
+//             ++it)
+//         {
+//             (*it)->interrupt();
+//         }
+//     }
+        
+
+//     size_t thread_group::size() const
+//     {
+//         return m_threads.size();
+//     }
 
 }

src/win32/thread.cpp

@@ -29,26 +29,13 @@ namespace boost
 
         void create_current_thread_tls_key()
         {
-            tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in
             current_thread_tls_key=TlsAlloc();
             BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);
         }
 
-        void cleanup_tls_key()
-        {
-            if(current_thread_tls_key)
-            {
-                TlsFree(current_thread_tls_key);
-                current_thread_tls_key=0;
-            }
-        }
-
         detail::thread_data_base* get_current_thread_data()
         {
-            if(!current_thread_tls_key)
-            {
-                return 0;
-            }
+            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
             return (detail::thread_data_base*)TlsGetValue(current_thread_tls_key);
         }
 
@@ -154,8 +141,8 @@ namespace boost
                     }
                 }
                 
-                set_current_thread_data(0);
             }
+            set_current_thread_data(0);
         }
         
         unsigned __stdcall thread_start_function(void* param)
@@ -169,12 +156,10 @@ namespace boost
             catch(thread_interrupted const&)
             {
             }
-// Removed as it stops the debugger identifying the cause of the exception
-// Unhandled exceptions still cause the application to terminate
-//             catch(...)
-//             {
-//                 std::terminate();
-//             }
+            catch(...)
+            {
+                std::terminate();
+            }
             run_thread_exit_callbacks();
             return 0;
         }
@@ -559,9 +544,10 @@ namespace boost
         
         void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing)
         {
+            tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in
             if(tss_data_node* const current_node=find_tss_data(key))
             {
-                if(cleanup_existing && current_node->func.get() && current_node->value)
+                if(cleanup_existing && current_node->func.get())
                 {
                     (*current_node->func)(current_node->value);
                 }
@@ -586,9 +572,7 @@ extern "C" BOOST_THREAD_DECL void on_thread_enter()
 {}
 
 extern "C" BOOST_THREAD_DECL void on_process_exit()
-{
-    boost::cleanup_tls_key();
-}
+{}
 
 extern "C" BOOST_THREAD_DECL void on_thread_exit()
 {

src/win32/tss_pe.cpp

@@ -26,11 +26,11 @@ namespace {
     {
         switch (dwReason)
         {
-        case DLL_THREAD_DETACH:
-        {
-            on_thread_exit();
-            break;
-        }
+            case DLL_THREAD_DETACH:
+            {
+                on_thread_exit();
+                break;
+            }
         }
     }
 
@@ -125,10 +125,10 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma section(".CRT$XCU",long,read)
 #pragma section(".CRT$XTU",long,read)
 #pragma section(".CRT$XLC",long,read)
-        __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
-        __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
-        __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
-        __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
+        static __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
+        static __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
+        static __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
+        static __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
 #else
         #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
         #   pragma data_seg(push, old_seg)
@@ -168,7 +168,6 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma warning(push)
 #pragma warning(disable:4189)
 #endif
-
         PVAPI on_tls_prepare(void)
         {
             //The following line has an important side effect:
@@ -240,32 +239,15 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
         {
             switch (dwReason)
             {
-            case DLL_THREAD_DETACH:
-                on_thread_exit();
-                break;
+                case DLL_THREAD_DETACH:
+                {
+                    on_thread_exit();
+                    break;
+                }
             }
         }
-
-        BOOL WINAPI dll_callback(HANDLE, DWORD dwReason, LPVOID)
-        {
-            switch (dwReason)
-            {
-            case DLL_THREAD_DETACH:
-                on_thread_exit();
-                break;
-            case DLL_PROCESS_DETACH:
-                on_process_exit();
-                break;
-            }
-            return true;
-        }
     } //namespace
 
-extern "C"
-{
-    extern BOOL (WINAPI * const _pRawDllMain)(HANDLE, DWORD, LPVOID)=&dll_callback;
-}
-
     extern "C" void tss_cleanup_implemented(void)
     {
         /*

test/CMakeLists.txt

@@ -1,39 +0,0 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-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/Jamfile.v2

@@ -38,8 +38,6 @@ rule thread-run ( sources )
           [ thread-run test_thread_id.cpp ]
           [ thread-run test_hardware_concurrency.cpp ]
           [ thread-run test_thread_move.cpp ]
-          [ thread-run test_thread_return_local.cpp ]
-          [ thread-run test_thread_move_return.cpp ]
           [ thread-run test_thread_launching.cpp ]
           [ thread-run test_thread_mf.cpp ]
           [ thread-run test_move_function.cpp ]

test/test_mutex.cpp

@@ -7,7 +7,6 @@
 #include <boost/thread/detail/config.hpp>
 
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread_time.hpp>
 #include <boost/thread/condition.hpp>
@@ -97,86 +96,6 @@ struct test_trylock
     }
 };
 
-template<typename Mutex>
-struct test_lock_times_out_if_other_thread_has_lock
-{
-    typedef boost::unique_lock<Mutex> Lock;
-    
-    Mutex m;
-    boost::mutex done_mutex;
-    bool done;
-    bool locked;
-    boost::condition_variable done_cond;
-    
-    test_lock_times_out_if_other_thread_has_lock():
-        done(false),locked(false)
-    {}
-
-    void locking_thread()
-    {
-        Lock lock(m,boost::defer_lock);
-        lock.timed_lock(boost::posix_time::milliseconds(50));
-
-        boost::lock_guard<boost::mutex> lk(done_mutex);
-        locked=lock.owns_lock();
-        done=true;
-        done_cond.notify_one();
-    }
-
-    void locking_thread_through_constructor()
-    {
-        Lock lock(m,boost::posix_time::milliseconds(50));
-
-        boost::lock_guard<boost::mutex> lk(done_mutex);
-        locked=lock.owns_lock();
-        done=true;
-        done_cond.notify_one();
-    }
-
-    bool is_done() const
-    {
-        return done;
-    }
-
-    typedef test_lock_times_out_if_other_thread_has_lock<Mutex> this_type;
-    
-    void do_test(void (this_type::*test_func)())
-    {
-        Lock lock(m);
-
-        locked=false;
-        done=false;
-        
-        boost::thread t(test_func,this);
-
-        try
-        {
-            {
-                boost::mutex::scoped_lock lk(done_mutex);
-                BOOST_CHECK(done_cond.timed_wait(lk,boost::posix_time::seconds(2),
-                                                 boost::bind(&this_type::is_done,this)));
-                BOOST_CHECK(!locked);
-            }
-            
-            lock.unlock();
-            t.join();
-        }
-        catch(...)
-        {
-            lock.unlock();
-            t.join();
-            throw;
-        }
-    }
-    
-
-    void operator()()
-    {
-        do_test(&this_type::locking_thread);
-        do_test(&this_type::locking_thread_through_constructor);
-    }
-};
-
 template <typename M>
 struct test_timedlock
 {
@@ -190,8 +109,6 @@ struct test_timedlock
 
     void operator()()
     {
-        test_lock_times_out_if_other_thread_has_lock<mutex_type>()();
-        
         mutex_type mutex;
         boost::condition condition;
 
@@ -261,7 +178,6 @@ struct test_recursive_lock
     }
 };
 
-
 void do_test_mutex()
 {
     test_lock<boost::mutex>()();

test/test_thread_move.cpp

@@ -1,48 +1,30 @@
-// Copyright (C) 2007-9 Anthony Williams
+// Copyright (C) 2007 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)
 #include <boost/thread/thread.hpp>
 #include <boost/test/unit_test.hpp>
 
-void do_nothing(boost::thread::id* my_id)
-{
-    *my_id=boost::this_thread::get_id();
-}
+void do_nothing()
+{}
 
 void test_move_on_construction()
 {
-    boost::thread::id the_id;
-    boost::thread x=boost::thread(do_nothing,&the_id);
-    boost::thread::id x_id=x.get_id();
+    boost::thread x=boost::thread(do_nothing);
     x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
 }
 
-boost::thread make_thread(boost::thread::id* the_id)
+boost::thread make_thread()
 {
-    return boost::thread(do_nothing,the_id);
+    return boost::thread(do_nothing);
 }
 
 void test_move_from_function_return()
 {
-    boost::thread::id the_id;
-    boost::thread x=make_thread(&the_id);
-    boost::thread::id x_id=x.get_id();
+    boost::thread x=make_thread();
     x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
 }
 
-void test_move_assign()
-{
-    boost::thread::id the_id;
-    boost::thread x(do_nothing,&the_id);
-    boost::thread y;
-    y=boost::move(x);
-    boost::thread::id y_id=y.get_id();
-    y.join();
-    BOOST_CHECK_EQUAL(the_id,y_id);
-}
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
@@ -51,6 +33,5 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 
     test->add(BOOST_TEST_CASE(test_move_on_construction));
     test->add(BOOST_TEST_CASE(test_move_from_function_return));
-    test->add(BOOST_TEST_CASE(test_move_assign));
     return test;
 }

test/test_thread_move_return.cpp

@@ -1,35 +0,0 @@
-// Copyright (C) 2009 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)
-#include <boost/thread/thread.hpp>
-#include <boost/test/unit_test.hpp>
-
-void do_nothing(boost::thread::id* my_id)
-{
-    *my_id=boost::this_thread::get_id();
-}
-
-boost::thread make_thread_move_return(boost::thread::id* the_id)
-{
-    boost::thread t(do_nothing,the_id);
-    return boost::move(t);
-}
-
-void test_move_from_function_move_return()
-{
-    boost::thread::id the_id;
-    boost::thread x=make_thread_move_return(&the_id);
-    boost::thread::id x_id=x.get_id();
-    x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
-}
-
-boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
-{
-    boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: thread move test suite");
-
-    test->add(BOOST_TEST_CASE(test_move_from_function_move_return));
-    return test;
-}

test/test_thread_return_local.cpp

@@ -1,35 +0,0 @@
-// Copyright (C) 2009 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)
-#include <boost/thread/thread.hpp>
-#include <boost/test/unit_test.hpp>
-
-void do_nothing(boost::thread::id* my_id)
-{
-    *my_id=boost::this_thread::get_id();
-}
-
-boost::thread make_thread_return_local(boost::thread::id* the_id)
-{
-    boost::thread t(do_nothing,the_id);
-    return t;
-}
-
-void test_move_from_function_return_local()
-{
-    boost::thread::id the_id;
-    boost::thread x=make_thread_return_local(&the_id);
-    boost::thread::id x_id=x.get_id();
-    x.join();
-    BOOST_CHECK_EQUAL(the_id,x_id);
-}
-
-boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
-{
-    boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: thread move test suite");
-
-    test->add(BOOST_TEST_CASE(test_move_from_function_return_local));
-    return test;
-}

test/test_tss.cpp

@@ -310,39 +310,6 @@ void test_tss_does_no_cleanup_with_null_cleanup_function()
     timed_test(&do_test_tss_does_no_cleanup_with_null_cleanup_function, 2);
 }
 
-void thread_with_local_tss_ptr()
-{
-    {
-        boost::thread_specific_ptr<Dummy> local_tss(tss_custom_cleanup);
-
-        local_tss.reset(new Dummy);
-    }
-    BOOST_CHECK(tss_cleanup_called);
-    tss_cleanup_called=false;
-}
-
-
-void test_tss_does_not_call_cleanup_after_ptr_destroyed()
-{
-    boost::thread t(thread_with_local_tss_ptr);
-    t.join();
-    BOOST_CHECK(!tss_cleanup_called);
-}
-
-void test_tss_cleanup_not_called_for_null_pointer()
-{
-    boost::thread_specific_ptr<Dummy> local_tss(tss_custom_cleanup);
-    local_tss.reset(new Dummy);
-    tss_cleanup_called=false;
-    local_tss.reset(0);
-    BOOST_CHECK(tss_cleanup_called);
-    tss_cleanup_called=false;
-    local_tss.reset(new Dummy);
-    BOOST_CHECK(!tss_cleanup_called);
-}
-
-
-
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
     boost::unit_test_framework::test_suite* test =
@@ -352,8 +319,6 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
     test->add(BOOST_TEST_CASE(test_tss_with_custom_cleanup));
     test->add(BOOST_TEST_CASE(test_tss_does_no_cleanup_after_release));
     test->add(BOOST_TEST_CASE(test_tss_does_no_cleanup_with_null_cleanup_function));
-    test->add(BOOST_TEST_CASE(test_tss_does_not_call_cleanup_after_ptr_destroyed));
-    test->add(BOOST_TEST_CASE(test_tss_cleanup_not_called_for_null_pointer));
 
     return test;
 }