Release 1.45.0 beta 1

[SVN r66473]

doc/tss.qbk

@@ -41,11 +41,6 @@ order. If a cleanup routine sets the value of associated with an instance of `bo
 cleaned up, that value is added to the cleanup list. Cleanup finishes when there are no outstanding instances of
 `boost::thread_specific_ptr` with values.
 
-Note: on some platforms, cleanup of thread-specific data is not
-performed for threads created with the platform's native API. On those
-platforms such cleanup is only done for threads that are started with
-`boost::thread` unless `boost::on_thread_exit()` is called manually
-from that thread.
 
 [section:thread_specific_ptr Class `thread_specific_ptr`]
 

include/boost/thread/pthread/condition_variable.hpp

@@ -47,39 +47,27 @@ namespace boost
     
     inline void condition_variable::wait(unique_lock<mutex>& m)
     {
-        int res=0;
-        {
-            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
-            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
-            guard.activate(m);
-            res=pthread_cond_wait(&cond,&internal_mutex);
-        }
+        thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
+        detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+        guard.activate(m);
+        int const res=pthread_cond_wait(&cond,&internal_mutex);
+        BOOST_ASSERT(!res);
         this_thread::interruption_point();
-        if(res)
-        {
-            boost::throw_exception(condition_error());
-        }
     }
 
     inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
     {
         thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
-        int cond_res;
-        {
-            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
-            guard.activate(m);
-            struct timespec const timeout=detail::get_timespec(wait_until);
-            cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
-        }
+        detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+        guard.activate(m);
+        struct timespec const timeout=detail::get_timespec(wait_until);
+        int const cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
         this_thread::interruption_point();
         if(cond_res==ETIMEDOUT)
         {
             return false;
         }
-        if(cond_res)
-        {
-            boost::throw_exception(condition_error());
-        }
+        BOOST_ASSERT(!cond_res);
         return true;
     }
 
@@ -133,8 +121,8 @@ namespace boost
                 detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
                 guard.activate(m);
                 res=pthread_cond_wait(&cond,&internal_mutex);
+                this_thread::interruption_point();
             }
-            this_thread::interruption_point();
             if(res)
             {
                 boost::throw_exception(condition_error());
@@ -157,8 +145,8 @@ namespace boost
                 detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
                 guard.activate(m);
                 res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+                this_thread::interruption_point();
             }
-            this_thread::interruption_point();
             if(res==ETIMEDOUT)
             {
                 return false;

include/boost/thread/win32/thread_data.hpp

@@ -145,9 +145,9 @@ namespace boost
             {}
         };
 
-        inline uintmax_t pin_to_zero(intmax_t value)
+        inline unsigned long pin_to_zero(long value)
         {
-            return (value<0)?0u:(uintmax_t)value;
+            return (value<0)?0u:(unsigned long)value;
         }
     }
 
@@ -156,7 +156,7 @@ namespace boost
         void BOOST_THREAD_DECL yield();
 
         bool BOOST_THREAD_DECL interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time);
-        inline void interruptible_wait(uintmax_t milliseconds)
+        inline void interruptible_wait(unsigned long milliseconds)
         {
             interruptible_wait(detail::win32::invalid_handle_value,milliseconds);
         }

src/pthread/once.cpp

@@ -22,18 +22,16 @@ namespace boost
             pthread_key_t epoch_tss_key;
             pthread_once_t epoch_tss_key_flag=PTHREAD_ONCE_INIT;
             
-            extern "C"
+            extern "C" void delete_epoch_tss_data(void* data)
             {
-                static void delete_epoch_tss_data(void* data)
-                {
-                    free(data);
-                }
-
-                static void create_epoch_tss_key()
-                {
-                    BOOST_VERIFY(!pthread_key_create(&epoch_tss_key,delete_epoch_tss_data));
-                }
+                free(data);
             }
+
+            extern "C" void create_epoch_tss_key()
+            {
+                BOOST_VERIFY(!pthread_key_create(&epoch_tss_key,delete_epoch_tss_data));
+            }
+            
         }
         
         boost::uintmax_t& get_once_per_thread_epoch()

src/pthread/thread.cpp

@@ -50,7 +50,7 @@ namespace boost
 
             extern "C"
             {
-                static void tls_destructor(void* data)
+                void tls_destructor(void* data)
                 {
                     boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
                     if(thread_info)
@@ -111,7 +111,7 @@ namespace boost
     {
         extern "C"
         {
-            static void* thread_proxy(void* param)
+            void* thread_proxy(void* param)
             {
                 boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->self;
                 thread_info->self.reset();

src/win32/thread.cpp

@@ -9,6 +9,7 @@
 
 #include <boost/thread/thread.hpp>
 #include <algorithm>
+#include <windows.h>
 #ifndef UNDER_CE
 #include <process.h>
 #endif
@@ -19,7 +20,6 @@
 #include <boost/throw_exception.hpp>
 #include <boost/thread/detail/tss_hooks.hpp>
 #include <boost/date_time/posix_time/conversion.hpp>
-#include <windows.h>
 
 namespace boost
 {
@@ -32,12 +32,7 @@ namespace boost
         {
             tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in
             current_thread_tls_key=TlsAlloc();
-			#if defined(UNDER_CE)
-				// Windows CE does not define the TLS_OUT_OF_INDEXES constant.
-				BOOST_ASSERT(current_thread_tls_key!=0xFFFFFFFF);
-			#else
-				BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);
-			#endif
+            BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);
         }
 
         void cleanup_tls_key()
@@ -61,13 +56,10 @@ namespace boost
         void set_current_thread_data(detail::thread_data_base* new_data)
         {
             boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
-            if(current_thread_tls_key)
-                BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
-            else
-                boost::throw_exception(thread_resource_error());
+            BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
         }
 
-#ifndef BOOST_HAS_THREADEX
+#ifdef BOOST_NO_THREADEX
 // Windows CE doesn't define _beginthreadex
 
         struct ThreadProxyData
@@ -229,15 +221,7 @@ namespace boost
         void make_external_thread_data()
         {
             externally_launched_thread* me=detail::heap_new<externally_launched_thread>();
-            try
-            {
-                set_current_thread_data(me);
-            }
-            catch(...)
-            {
-                detail::heap_delete(me);
-                throw;
-            }
+            set_current_thread_data(me);
         }
 
         detail::thread_data_base* get_or_make_current_thread_data()
@@ -556,8 +540,8 @@ namespace boost
         {
             detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
             thread_exit_callback_node* const new_node=
-                heap_new<thread_exit_callback_node>(
-                    func,current_thread_data->thread_exit_callbacks);
+                heap_new<thread_exit_callback_node>(func,
+                                                    current_thread_data->thread_exit_callbacks);
             current_thread_data->thread_exit_callbacks=new_node;
         }
 
@@ -599,11 +583,10 @@ namespace boost
                 current_node->func=func;
                 current_node->value=tss_data;
             }
-            else if(func && tss_data)
+            else
             {
                 detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-                tss_data_node* const new_node=
-                    heap_new<tss_data_node>(key,func,tss_data,current_thread_data->tss_data);
+                tss_data_node* const new_node=heap_new<tss_data_node>(key,func,tss_data,current_thread_data->tss_data);
                 current_thread_data->tss_data=new_node;
             }
         }

src/win32/tss_pe.cpp

@@ -11,7 +11,7 @@
 
 #if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) 
 
-#if (defined(__MINGW32__) && !defined(_WIN64)) || defined(__MINGW64__)
+#if defined(__MINGW32__) && !defined(_WIN64)
 
 #include <boost/thread/detail/tss_hooks.hpp>
 
@@ -38,8 +38,7 @@ namespace {
     }
 }
 
-#if defined(__MINGW64__) || (__MINGW32_MAJOR_VERSION >3) ||             \
-    ((__MINGW32_MAJOR_VERSION==3) && (__MINGW32_MINOR_VERSION>=18))
+#if (__MINGW32_MAJOR_VERSION >3) || ((__MINGW32_MAJOR_VERSION==3) && (__MINGW32_MINOR_VERSION>=18))
 extern "C"
 {
     PIMAGE_TLS_CALLBACK __crt_xl_tls_callback__ __attribute__ ((section(".CRT$XLB"))) = on_tls_callback;