Branch for working on the documentation tools documentation.

[SVN r68640]

build/Jamfile.v2

@@ -43,6 +43,7 @@ project boost/thread
       <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
       -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
       <tag>@$(__name__).tag
+      <toolset>gcc:<cxxflags>-Wno-long-long
     : default-build <threading>multi
     ;
 

doc/Jamfile.v2

@@ -26,11 +26,6 @@ boostbook standalone
         <xsl:param>generate.section.toc.level=10
         # Path for links to Boost:
         <xsl:param>boost.root=../../../..
-        # Path for libraries index:
-        <xsl:param>boost.libraries=../../../../libs/libraries.htm
-        # Use the main Boost stylesheet:
-        <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
-        
     ;
 
 

doc/tss.qbk

@@ -41,6 +41,11 @@ 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/detail/config.hpp

@@ -19,6 +19,12 @@
 
 #include "platform.hpp"
 
+// provided for backwards compatibility, since this
+// macro was used for several releases by mistake.
+#if defined(BOOST_THREAD_DYN_DLL)
+# define BOOST_THREAD_DYN_LINK
+#endif
+
 // compatibility with the rest of Boost's auto-linking code:
 #if defined(BOOST_THREAD_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
 # undef  BOOST_THREAD_USE_LIB

include/boost/thread/detail/platform.hpp

@@ -29,7 +29,7 @@
 #  define BOOST_THREAD_HPUX
 #elif defined(__CYGWIN__)
 #  define BOOST_THREAD_CYGWIN
-#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+#elif (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(BOOST_DISABLE_WIN32)
 #  define BOOST_THREAD_WIN32
 #elif defined(__BEOS__)
 #  define BOOST_THREAD_BEOS

include/boost/thread/detail/thread.hpp

@@ -115,14 +115,13 @@ namespace boost
 
         void release_handle();
         
-        mutable boost::mutex thread_info_mutex;
         detail::thread_data_ptr thread_info;
 
         void start_thread();
         
         explicit thread(detail::thread_data_ptr data);
 
-        detail::thread_data_ptr get_thread_info() const;
+        detail::thread_data_ptr get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const;
 
 #ifndef BOOST_NO_RVALUE_REFERENCES
         template<typename F>
@@ -159,7 +158,7 @@ namespace boost
 #ifdef BOOST_MSVC
         template <class F>
         explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
-            thread_info(make_thread_info(f))
+            thread_info(make_thread_info(static_cast<F&&>(f)))
         {
             start_thread();
         }
@@ -433,6 +432,7 @@ namespace boost
         }
 
 #ifndef BOOST_NO_IOSTREAM
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
         template<class charT, class traits>
         friend std::basic_ostream<charT, traits>& 
         operator<<(std::basic_ostream<charT, traits>& os, const id& x)
@@ -446,9 +446,34 @@ namespace boost
                 return os<<"{Not-any-thread}";
             }
         }
+#else
+        template<class charT, class traits>
+        std::basic_ostream<charT, traits>& 
+        print(std::basic_ostream<charT, traits>& os) const
+        {
+            if(thread_data)
+            {
+                return os<<thread_data;
+            }
+            else
+            {
+                return os<<"{Not-any-thread}";
+            }
+        }
+
+#endif
 #endif
     };
 
+#if !defined(BOOST_NO_IOSTREAM) && defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    template<class charT, class traits>
+    std::basic_ostream<charT, traits>& 
+    operator<<(std::basic_ostream<charT, traits>& os, const thread::id& x)
+    {
+        return x.print(os);
+    }
+#endif
+
     inline bool thread::operator==(const thread& other) const
     {
         return get_id()==other.get_id();

include/boost/thread/future.hpp

@@ -142,6 +142,8 @@ namespace boost
                 {
                     lock.lock();
                 }
+            private:
+                relocker& operator=(relocker const&);
             };
 
             void do_callback(boost::unique_lock<boost::mutex>& lock)
@@ -552,6 +554,9 @@ namespace boost
     template<typename Iterator>
     typename boost::disable_if<is_future_type<Iterator>,Iterator>::type wait_for_any(Iterator begin,Iterator end)
     {
+        if(begin==end)
+            return end;
+        
         detail::future_waiter waiter;
         for(Iterator current=begin;current!=end;++current)
         {
@@ -907,10 +912,10 @@ namespace boost
 
         void lazy_init()
         {
-            if(!future)
+            if(!atomic_load(&future))
             {
-                future_obtained=false;
-                future.reset(new detail::future_object<R>);
+                future_ptr blank;
+                atomic_compare_exchange(&future,&blank,future_ptr(new detail::future_object<R>));
             }
         }
         
@@ -940,12 +945,14 @@ namespace boost
             future_obtained(rhs.future_obtained)
         {
             future.swap(rhs.future);
+            rhs.future_obtained=false;
         }
         promise & operator=(promise&& rhs)
         {
             future.swap(rhs.future);
             future_obtained=rhs.future_obtained;
             rhs.future.reset();
+            rhs.future_obtained=false;
             return *this;
         }
 #else
@@ -953,12 +960,14 @@ namespace boost
             future(rhs->future),future_obtained(rhs->future_obtained)
         {
             rhs->future.reset();
+            rhs->future_obtained=false;
         }
         promise & operator=(boost::detail::thread_move_t<promise> rhs)
         {
             future=rhs->future;
             future_obtained=rhs->future_obtained;
             rhs->future.reset();
+            rhs->future_obtained=false;
             return *this;
         }
 
@@ -1042,10 +1051,10 @@ namespace boost
 
         void lazy_init()
         {
-            if(!future)
+            if(!atomic_load(&future))
             {
-                future_obtained=false;
-                future.reset(new detail::future_object<void>);
+                future_ptr blank;
+                atomic_compare_exchange(&future,&blank,future_ptr(new detail::future_object<void>));
             }
         }
     public:
@@ -1074,12 +1083,14 @@ namespace boost
             future_obtained(rhs.future_obtained)
         {
             future.swap(rhs.future);
+            rhs.future_obtained=false;
         }
         promise & operator=(promise&& rhs)
         {
             future.swap(rhs.future);
             future_obtained=rhs.future_obtained;
             rhs.future.reset();
+            rhs.future_obtained=false;
             return *this;
         }
 #else
@@ -1087,12 +1098,14 @@ namespace boost
             future(rhs->future),future_obtained(rhs->future_obtained)
         {
             rhs->future.reset();
+            rhs->future_obtained=false;
         }
         promise & operator=(boost::detail::thread_move_t<promise> rhs)
         {
             future=rhs->future;
             future_obtained=rhs->future_obtained;
             rhs->future.reset();
+            rhs->future_obtained=false;
             return *this;
         }
 

include/boost/thread/locks.hpp

@@ -277,7 +277,7 @@ namespace boost
         unique_lock& operator=(unique_lock&);
         unique_lock& operator=(upgrade_lock<Mutex>& other);
     public:
-#ifdef __SUNPRO_CC 
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) 
         unique_lock(const volatile unique_lock&); 
 #endif
         unique_lock():
@@ -363,7 +363,7 @@ namespace boost
             return detail::thread_move_t<unique_lock<Mutex> >(*this);
         }
 
-#ifdef __SUNPRO_CC
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) 
         unique_lock& operator=(unique_lock<Mutex> other) 
         { 
             swap(other); 
@@ -489,7 +489,13 @@ namespace boost
     template<typename Mutex>
     inline upgrade_lock<Mutex>&& move(upgrade_lock<Mutex>&& ul)
     {
-        return ul;
+        return static_cast<upgrade_lock<Mutex>&&>(ul);
+    }
+
+    template<typename Mutex>
+    inline upgrade_lock<Mutex>&& move(upgrade_lock<Mutex>& ul)
+    {
+        return static_cast<upgrade_lock<Mutex>&&>(ul);
     }
 #endif
     template<typename Mutex>
@@ -768,14 +774,14 @@ namespace boost
 
         upgrade_lock& operator=(upgrade_lock<Mutex>&& other)
         {
-            upgrade_lock temp(other);
+            upgrade_lock temp(static_cast<upgrade_lock<Mutex>&&>(other));
             swap(temp);
             return *this;
         }
 
         upgrade_lock& operator=(unique_lock<Mutex>&& other)
         {
-            upgrade_lock temp(other);
+            upgrade_lock temp(static_cast<unique_lock<Mutex>&&>(other));
             swap(temp);
             return *this;
         }
@@ -1041,15 +1047,15 @@ namespace boost
                 return *this;
             }
 
-            void swap(try_lock_wrapper& other)
-            {
-                base::swap(other);
-            }
             void swap(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
             {
                 base::swap(*other);
             }
 #endif
+            void swap(try_lock_wrapper& other)
+            {
+                base::swap(other);
+            }
             void lock()
             {
                 base::lock();
@@ -1234,7 +1240,7 @@ namespace boost
         {
             unsigned const lock_count=2;
             unsigned lock_first=0;
-            while(true)
+            for(;;)
             {
                 switch(lock_first)
                 {
@@ -1287,7 +1293,7 @@ namespace boost
     {
         unsigned const lock_count=3;
         unsigned lock_first=0;
-        while(true)
+        for(;;)
         {
             switch(lock_first)
             {
@@ -1319,7 +1325,7 @@ namespace boost
     {
         unsigned const lock_count=4;
         unsigned lock_first=0;
-        while(true)
+        for(;;)
         {
             switch(lock_first)
             {
@@ -1357,7 +1363,7 @@ namespace boost
     {
         unsigned const lock_count=5;
         unsigned lock_first=0;
-        while(true)
+        for(;;)
         {
             switch(lock_first)
             {

include/boost/thread/pthread/condition_variable.hpp

@@ -14,32 +14,81 @@
 
 namespace boost
 {
+    namespace this_thread
+    {
+        void BOOST_THREAD_DECL interruption_point();
+    }
+    
+    namespace thread_cv_detail
+    {
+        template<typename MutexType>
+        struct lock_on_exit
+        {
+            MutexType* m;
+            
+            lock_on_exit():
+                m(0)
+            {}
+
+            void activate(MutexType& m_)
+            {
+                m_.unlock();
+                m=&m_;
+            }
+            ~lock_on_exit()
+            {
+                if(m)
+                {
+                    m->lock();
+                }
+           }
+        };
+    }
+    
     inline void condition_variable::wait(unique_lock<mutex>& m)
     {
-        detail::interruption_checker check_for_interruption(&cond);
-        BOOST_VERIFY(!pthread_cond_wait(&cond,m.mutex()->native_handle()));
+        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);
+            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)
     {
-        detail::interruption_checker check_for_interruption(&cond);
+        thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
+        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,m.mutex()->native_handle(),&timeout);
+        int const cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+        this_thread::interruption_point();
         if(cond_res==ETIMEDOUT)
         {
             return false;
         }
-        BOOST_ASSERT(!cond_res);
+        if(cond_res)
+        {
+            boost::throw_exception(condition_error());
+        }
         return true;
     }
 
     inline void condition_variable::notify_one()
     {
+        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
         BOOST_VERIFY(!pthread_cond_signal(&cond));
     }
         
     inline void condition_variable::notify_all()
     {
+        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
         BOOST_VERIFY(!pthread_cond_broadcast(&cond));
     }
     
@@ -77,13 +126,11 @@ namespace boost
         {
             int res=0;
             {
-                detail::interruption_checker check_for_interruption(&cond);
-                {
-                    boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-                    m.unlock();
-                    res=pthread_cond_wait(&cond,&internal_mutex);
-                }
-                m.lock();
+                thread_cv_detail::lock_on_exit<lock_type> guard;
+                detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+                guard.activate(m);
+                res=pthread_cond_wait(&cond,&internal_mutex);
+                this_thread::interruption_point();
             }
             if(res)
             {
@@ -103,13 +150,11 @@ namespace boost
             struct timespec const timeout=detail::get_timespec(wait_until);
             int res=0;
             {
-                detail::interruption_checker check_for_interruption(&cond);
-                {
-                    boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-                    m.unlock();
-                    res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
-                }
-                m.lock();
+                thread_cv_detail::lock_on_exit<lock_type> guard;
+                detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+                guard.activate(m);
+                res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+                this_thread::interruption_point();
             }
             if(res==ETIMEDOUT)
             {

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -20,6 +20,7 @@ namespace boost
     class condition_variable
     {
     private:
+        pthread_mutex_t internal_mutex;
         pthread_cond_t cond;
         
         condition_variable(condition_variable&);
@@ -28,14 +29,21 @@ namespace boost
     public:
         condition_variable()
         {
-            int const res=pthread_cond_init(&cond,NULL);
+            int const res=pthread_mutex_init(&internal_mutex,NULL);
             if(res)
             {
                 boost::throw_exception(thread_resource_error());
             }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+                boost::throw_exception(thread_resource_error());
+            }
         }
         ~condition_variable()
         {
+            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
             BOOST_VERIFY(!pthread_cond_destroy(&cond));
         }
 

include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp

@@ -18,15 +18,25 @@ namespace boost
         class pthread_mutex_scoped_lock
         {
             pthread_mutex_t* m;
+            bool locked;
         public:
             explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
-                m(m_)
+                m(m_),locked(true)
             {
                 BOOST_VERIFY(!pthread_mutex_lock(m));
             }
-            ~pthread_mutex_scoped_lock()
+            void unlock()
             {
                 BOOST_VERIFY(!pthread_mutex_unlock(m));
+                locked=false;
+            }
+            
+            ~pthread_mutex_scoped_lock()
+            {
+                if(locked)
+                {
+                    unlock();
+                }
             }
             
         };

include/boost/thread/pthread/recursive_mutex.hpp

@@ -26,6 +26,10 @@
 #endif
 #endif
 
+#if defined(BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE) && defined(BOOST_PTHREAD_HAS_TIMEDLOCK)
+#define BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
+#endif
+
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
@@ -36,9 +40,16 @@ namespace boost
         recursive_mutex(recursive_mutex const&);
         recursive_mutex& operator=(recursive_mutex const&);        
         pthread_mutex_t m;
+#ifndef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
+        pthread_cond_t cond;
+        bool is_locked;
+        pthread_t owner;
+        unsigned count;
+#endif
     public:
         recursive_mutex()
         {
+#ifdef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
             pthread_mutexattr_t attr;
             
             int const init_attr_res=pthread_mutexattr_init(&attr);
@@ -49,21 +60,42 @@ namespace boost
             int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
             if(set_attr_res)
             {
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
                 boost::throw_exception(thread_resource_error());
             }
             
             int const res=pthread_mutex_init(&m,&attr);
             if(res)
             {
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
                 boost::throw_exception(thread_resource_error());
             }
             BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+#else
+            int const res=pthread_mutex_init(&m,NULL);
+            if(res)
+            {
+                boost::throw_exception(thread_resource_error());
+            }
+            int const res2=pthread_cond_init(&cond,NULL);
+            if(res2)
+            {
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                boost::throw_exception(thread_resource_error());
+            }
+            is_locked=false;
+            count=0;
+#endif
         }
         ~recursive_mutex()
         {
             BOOST_VERIFY(!pthread_mutex_destroy(&m));
+#ifndef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+#endif
         }
-        
+
+#ifdef BOOST_PTHREAD_HAS_MUTEXATTR_SETTYPE
         void lock()
         {
             BOOST_VERIFY(!pthread_mutex_lock(&m));
@@ -80,13 +112,56 @@ namespace boost
             BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }
-
         typedef pthread_mutex_t* native_handle_type;
         native_handle_type native_handle()
         {
             return &m;
         }
 
+#else
+        void lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && pthread_equal(owner,pthread_self()))
+            {
+                ++count;
+                return;
+            }
+            
+            while(is_locked)
+            {
+                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+        }
+
+        void unlock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(!--count)
+            {
+                is_locked=false;
+            }
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
+        }
+        
+        bool try_lock()
+        {
+            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
+            if(is_locked && !pthread_equal(owner,pthread_self()))
+            {
+                return false;
+            }
+            is_locked=true;
+            ++count;
+            owner=pthread_self();
+            return true;
+        }
+
+#endif
+
         typedef unique_lock<recursive_mutex> scoped_lock;
         typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
     };
@@ -100,7 +175,7 @@ namespace boost
         recursive_timed_mutex& operator=(recursive_timed_mutex const&);        
     private:
         pthread_mutex_t m;
-#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+#ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
         pthread_cond_t cond;
         bool is_locked;
         pthread_t owner;
@@ -109,7 +184,7 @@ namespace boost
     public:
         recursive_timed_mutex()
         {
-#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
+#ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
             pthread_mutexattr_t attr;
             
             int const init_attr_res=pthread_mutexattr_init(&attr);
@@ -149,7 +224,7 @@ namespace boost
         ~recursive_timed_mutex()
         {
             BOOST_VERIFY(!pthread_mutex_destroy(&m));
-#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
+#ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
             BOOST_VERIFY(!pthread_cond_destroy(&cond));
 #endif
         }
@@ -160,7 +235,7 @@ namespace boost
             return timed_lock(get_system_time()+relative_time);
         }
 
-#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
+#ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
         void lock()
         {
             BOOST_VERIFY(!pthread_mutex_lock(&m));

include/boost/thread/pthread/thread_data.hpp

@@ -12,6 +12,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/optional.hpp>
 #include <pthread.h>
+#include <boost/assert.hpp>
 #include "condition_variable_fwd.hpp"
 #include <map>
 
@@ -55,6 +56,7 @@ namespace boost
             std::map<void const*,boost::detail::tss_data_node> tss_data;
             bool interrupt_enabled;
             bool interrupt_requested;
+            pthread_mutex_t* cond_mutex;
             pthread_cond_t* current_cond;
 
             thread_data_base():
@@ -76,6 +78,8 @@ namespace boost
         class interruption_checker
         {
             thread_data_base* const thread_info;
+            pthread_mutex_t* m;
+            bool set;
 
             void check_for_interruption()
             {
@@ -88,23 +92,35 @@ namespace boost
             
             void operator=(interruption_checker&);
         public:
-            explicit interruption_checker(pthread_cond_t* cond):
-                thread_info(detail::get_current_thread_data())
+            explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
+                thread_info(detail::get_current_thread_data()),m(cond_mutex),
+                set(thread_info && thread_info->interrupt_enabled)
             {
-                if(thread_info && thread_info->interrupt_enabled)
+                if(set)
                 {
                     lock_guard<mutex> guard(thread_info->data_mutex);
                     check_for_interruption();
+                    thread_info->cond_mutex=cond_mutex;
                     thread_info->current_cond=cond;
+                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                }
+                else
+                {
+                    BOOST_VERIFY(!pthread_mutex_lock(m));
                 }
             }
             ~interruption_checker()
             {
-                if(thread_info && thread_info->interrupt_enabled)
+                if(set)
                 {
+                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                     lock_guard<mutex> guard(thread_info->data_mutex);
+                    thread_info->cond_mutex=NULL;
                     thread_info->current_cond=NULL;
-                    check_for_interruption();
+                }
+                else
+                {
+                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                 }
             }
         };

include/boost/thread/thread_time.hpp

@@ -6,6 +6,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/date_time/time_clock.hpp>
 #include <boost/date_time/microsec_time_clock.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 
@@ -17,7 +18,11 @@ namespace boost
     
     inline system_time get_system_time()
     {
+#if defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
         return boost::date_time::microsec_clock<system_time>::universal_time();
+#else // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
+        return boost::date_time::second_clock<system_time>::universal_time();
+#endif // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
     }
 
     namespace detail

include/boost/thread/win32/once.hpp

@@ -34,42 +34,85 @@ namespace boost
     {
         long status;
         long count;
-        long throw_count;
-        void* event_handle;
-
-        ~once_flag()
-        {
-            if(count)
-            {
-                BOOST_ASSERT(count==throw_count);
-            }
-            
-            void* const old_event=BOOST_INTERLOCKED_EXCHANGE_POINTER(&event_handle,0);
-            if(old_event)
-            {
-                ::boost::detail::win32::CloseHandle(old_event);
-            }
-        }
     };
 
-#define BOOST_ONCE_INIT {0,0,0,0}
+#define BOOST_ONCE_INIT {0,0}
 
     namespace detail
     {
-        inline void* allocate_event_handle(void*& handle)
+#ifdef BOOST_NO_ANSI_APIS
+        typedef wchar_t once_char_type;
+#else
+        typedef char once_char_type;
+#endif
+        unsigned const once_mutex_name_fixed_length=54;
+        unsigned const once_mutex_name_length=once_mutex_name_fixed_length+
+            sizeof(void*)*2+sizeof(unsigned long)*2+1;
+
+        template <class I>
+        void int_to_string(I p, once_char_type* buf)
         {
-            void* const new_handle=::boost::detail::win32::create_anonymous_event(
-                ::boost::detail::win32::manual_reset_event,
-                ::boost::detail::win32::event_initially_reset);
-            
-            void* event_handle=BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&handle,
-                                                                          new_handle,0);
-            if(event_handle)
+            for(unsigned i=0; i < sizeof(I)*2; ++i,++buf)
             {
-                ::boost::detail::win32::CloseHandle(new_handle);
-                return event_handle;
+#ifdef BOOST_NO_ANSI_APIS
+                once_char_type const a=L'A';
+#else
+                once_char_type const a='A';
+#endif
+                *buf = a + static_cast<once_char_type>((p >> (i*4)) & 0x0f);
             }
-            return new_handle;
+            *buf = 0;
+        }
+
+        inline void name_once_mutex(once_char_type* mutex_name,void* flag_address)
+        {
+#ifdef BOOST_NO_ANSI_APIS
+            static const once_char_type fixed_mutex_name[]=L"Local\\{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+#else
+            static const once_char_type fixed_mutex_name[]="Local\\{C15730E2-145C-4c5e-B005-3BC753F42475}-once-flag";
+#endif
+            BOOST_STATIC_ASSERT(sizeof(fixed_mutex_name) == 
+                                (sizeof(once_char_type)*(once_mutex_name_fixed_length+1)));
+            
+            std::memcpy(mutex_name,fixed_mutex_name,sizeof(fixed_mutex_name));
+            detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address), 
+                                  mutex_name + once_mutex_name_fixed_length);
+            detail::int_to_string(win32::GetCurrentProcessId(), 
+                                  mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
+        }
+                        
+        inline void* open_once_event(once_char_type* mutex_name,void* flag_address)
+        {
+            if(!*mutex_name)
+            {
+                name_once_mutex(mutex_name,flag_address);
+            }
+            
+#ifdef BOOST_NO_ANSI_APIS                        
+            return ::boost::detail::win32::OpenEventW(
+#else
+            return ::boost::detail::win32::OpenEventA(
+#endif
+                ::boost::detail::win32::synchronize | 
+                ::boost::detail::win32::event_modify_state,
+                false,
+                mutex_name);
+        }
+
+        inline void* create_once_event(once_char_type* mutex_name,void* flag_address)
+        {
+            if(!*mutex_name)
+            {
+                name_once_mutex(mutex_name,flag_address);
+            }
+#ifdef BOOST_NO_ANSI_APIS                        
+            return ::boost::detail::win32::CreateEventW(
+#else
+            return ::boost::detail::win32::CreateEventA(
+#endif
+                0,::boost::detail::win32::manual_reset_event,
+                ::boost::detail::win32::event_initially_reset,
+                mutex_name);
         }
     }
     
@@ -83,8 +126,9 @@ namespace boost
         long const running_value=0x7f0725e3;
         long status;
         bool counted=false;
-        void* event_handle=0;
-        long throw_count=0;
+        detail::win32::handle_manager event_handle;
+        detail::once_char_type mutex_name[detail::once_mutex_name_length];
+        mutex_name[0]=0;
 
         while((status=::boost::detail::interlocked_read_acquire(&flag.status))
               !=function_complete_flag_value)
@@ -96,7 +140,7 @@ namespace boost
                 {
                     if(!event_handle)
                     {
-                        event_handle=::boost::detail::interlocked_read_acquire(&flag.event_handle);
+                        event_handle=detail::open_once_event(mutex_name,&flag);
                     }
                     if(event_handle)
                     {
@@ -112,25 +156,20 @@ namespace boost
                     if(!event_handle && 
                        (::boost::detail::interlocked_read_acquire(&flag.count)>1))
                     {
-                        event_handle=::boost::detail::allocate_event_handle(flag.event_handle);
+                        event_handle=detail::create_once_event(mutex_name,&flag);
                     }
                     if(event_handle)
                     {
                         ::boost::detail::win32::SetEvent(event_handle);
                     }
-                    throw_count=::boost::detail::interlocked_read_acquire(&flag.throw_count);
                     break;
                 }
                 catch(...)
                 {
-                    if(counted)
-                    {
-                        BOOST_INTERLOCKED_INCREMENT(&flag.throw_count);
-                    }
                     BOOST_INTERLOCKED_EXCHANGE(&flag.status,0);
                     if(!event_handle)
                     {
-                        event_handle=::boost::detail::interlocked_read_acquire(&flag.event_handle);
+                        event_handle=detail::open_once_event(mutex_name,&flag);
                     }
                     if(event_handle)
                     {
@@ -149,31 +188,15 @@ namespace boost
                 {
                     break;
                 }
-                event_handle=::boost::detail::interlocked_read_acquire(&flag.event_handle);
                 if(!event_handle)
                 {
-                    event_handle=::boost::detail::allocate_event_handle(flag.event_handle);
+                    event_handle=detail::create_once_event(mutex_name,&flag);
                     continue;
                 }
             }
             BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObject(
                              event_handle,::boost::detail::win32::infinite));
         }
-        if(counted || throw_count)
-        {
-            if(!BOOST_INTERLOCKED_EXCHANGE_ADD(&flag.count,(counted?-1:0)-throw_count))
-            {
-                if(!event_handle)
-                {
-                    event_handle=::boost::detail::interlocked_read_acquire(&flag.event_handle);
-                }
-                if(event_handle)
-                {
-                    BOOST_INTERLOCKED_EXCHANGE_POINTER(&flag.event_handle,0);
-                    ::boost::detail::win32::CloseHandle(event_handle);
-                }
-            }
-        }
     }
 }
 

include/boost/thread/win32/thread_primitives.hpp

@@ -31,14 +31,18 @@ namespace boost
             unsigned const infinite=INFINITE;
             unsigned const timeout=WAIT_TIMEOUT;
             handle const invalid_handle_value=INVALID_HANDLE_VALUE;
+            unsigned const event_modify_state=EVENT_MODIFY_STATE;
+            unsigned const synchronize=SYNCHRONIZE;
 
 # ifdef BOOST_NO_ANSI_APIS
             using ::CreateMutexW;
             using ::CreateEventW;
+            using ::OpenEventW;
             using ::CreateSemaphoreW;
 # else
             using ::CreateMutexA;
             using ::CreateEventA;
+            using ::OpenEventA;
             using ::CreateSemaphoreA;
 # endif
             using ::CloseHandle;
@@ -100,6 +104,8 @@ namespace boost
             unsigned const infinite=~0U;
             unsigned const timeout=258U;
             handle const invalid_handle_value=(handle)(-1);
+            unsigned const event_modify_state=2;
+            unsigned const synchronize=0x100000u;
 
             extern "C"
             {
@@ -108,10 +114,12 @@ namespace boost
                 __declspec(dllimport) void* __stdcall CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
                 __declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
                 __declspec(dllimport) void* __stdcall CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall OpenEventW(unsigned long,int,wchar_t const*);
 # else
                 __declspec(dllimport) void* __stdcall CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
                 __declspec(dllimport) void* __stdcall CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
                 __declspec(dllimport) void* __stdcall CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+                __declspec(dllimport) void* __stdcall OpenEventA(unsigned long,int,char const*);
 # endif
                 __declspec(dllimport) int __stdcall CloseHandle(void*);
                 __declspec(dllimport) int __stdcall ReleaseMutex(void*);

src/pthread/thread.cpp

@@ -196,15 +196,14 @@ namespace boost
         detach();
     }
 
-    detail::thread_data_ptr thread::get_thread_info() const
+    detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const
     {
-        lock_guard<mutex> l(thread_info_mutex);
         return thread_info;
     }
 
     void thread::join()
     {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             bool do_join=false;
@@ -238,7 +237,6 @@ namespace boost
                 local_thread_info->done_condition.notify_all();
             }
             
-            lock_guard<mutex> l1(thread_info_mutex);
             if(thread_info==local_thread_info)
             {
                 thread_info.reset();
@@ -248,7 +246,7 @@ namespace boost
 
     bool thread::timed_join(system_time const& wait_until)
     {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             bool do_join=false;
@@ -285,7 +283,6 @@ namespace boost
                 local_thread_info->done_condition.notify_all();
             }
             
-            lock_guard<mutex> l1(thread_info_mutex);
             if(thread_info==local_thread_info)
             {
                 thread_info.reset();
@@ -296,17 +293,14 @@ namespace boost
 
     bool thread::joinable() const
     {
-        return get_thread_info();
+        return (get_thread_info)();
     }
 
 
     void thread::detach()
     {
         detail::thread_data_ptr local_thread_info;
-        {
-            lock_guard<mutex> l1(thread_info_mutex);
-            thread_info.swap(local_thread_info);
-        }
+        thread_info.swap(local_thread_info);
         
         if(local_thread_info)
         {
@@ -385,11 +379,11 @@ namespace boost
         int count;
         size_t size=sizeof(count);
         return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
-#elif defined(_GNU_SOURCE)
-        return get_nprocs();
 #elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
         int const count=sysconf(_SC_NPROCESSORS_ONLN);
         return (count>0)?count:0;
+#elif defined(_GNU_SOURCE)
+        return get_nprocs();
 #else
         return 0;
 #endif
@@ -397,7 +391,7 @@ namespace boost
 
     thread::id thread::get_id() const
     {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             return id(local_thread_info);
@@ -410,13 +404,14 @@ namespace boost
 
     void thread::interrupt()
     {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             lock_guard<mutex> lk(local_thread_info->data_mutex);
             local_thread_info->interrupt_requested=true;
             if(local_thread_info->current_cond)
             {
+                boost::pthread::pthread_mutex_scoped_lock internal_lock(local_thread_info->cond_mutex);
                 BOOST_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond));
             }
         }
@@ -424,7 +419,7 @@ namespace boost
 
     bool thread::interruption_requested() const
     {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             lock_guard<mutex> lk(local_thread_info->data_mutex);
@@ -438,7 +433,7 @@ namespace boost
 
     thread::native_handle_type thread::native_handle()
     {
-        detail::thread_data_ptr const local_thread_info=get_thread_info();
+        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             lock_guard<mutex> lk(local_thread_info->data_mutex);

src/tss_null.cpp

@@ -8,13 +8,15 @@
 
 #if defined(BOOST_HAS_WINTHREADS) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))
 
+namespace boost 
+{
     /*
     This file is a "null" implementation of tss cleanup; it's
     purpose is to to eliminate link errors in cases
     where it is known that tss cleanup is not needed.
     */
 
-    extern "C" void tss_cleanup_implemented(void)
+    void tss_cleanup_implemented(void)
     {
         /*
         This function's sole purpose is to cause a link error in cases where
@@ -30,5 +32,7 @@
         longer needed and can be removed.
         */
     }
+	
+}
 
 #endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)

src/win32/thread.cpp

@@ -56,7 +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);
-            BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
+            if(current_thread_tls_key)
+                BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
+            else
+                boost::throw_exception(thread_resource_error());
         }
 
 #ifdef BOOST_NO_THREADEX
@@ -221,7 +224,15 @@ namespace boost
         void make_external_thread_data()
         {
             externally_launched_thread* me=detail::heap_new<externally_launched_thread>();
-            set_current_thread_data(me);
+            try
+            {
+                set_current_thread_data(me);
+            }
+            catch(...)
+            {
+                detail::heap_delete(me);
+                throw;
+            }
         }
 
         detail::thread_data_base* get_or_make_current_thread_data()
@@ -244,17 +255,17 @@ namespace boost
     
     thread::id thread::get_id() const
     {
-        return thread::id(get_thread_info());
+        return thread::id((get_thread_info)());
     }
 
     bool thread::joinable() const
     {
-        return get_thread_info();
+        return (get_thread_info)();
     }
 
     void thread::join()
     {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             this_thread::interruptible_wait(local_thread_info->thread_handle,detail::timeout::sentinel());
@@ -264,7 +275,7 @@ namespace boost
 
     bool thread::timed_join(boost::system_time const& wait_until)
     {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             if(!this_thread::interruptible_wait(local_thread_info->thread_handle,get_milliseconds_until(wait_until)))
@@ -283,13 +294,12 @@ namespace boost
 
     void thread::release_handle()
     {
-        lock_guard<mutex> l1(thread_info_mutex);
         thread_info=0;
     }
     
     void thread::interrupt()
     {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
             local_thread_info->interrupt();
@@ -298,7 +308,7 @@ namespace boost
     
     bool thread::interruption_requested() const
     {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
         return local_thread_info.get() && (detail::win32::WaitForSingleObject(local_thread_info->interruption_handle,0)==0);
     }
     
@@ -311,13 +321,12 @@ namespace boost
     
     thread::native_handle_type thread::native_handle()
     {
-        detail::thread_data_ptr local_thread_info=get_thread_info();
+        detail::thread_data_ptr local_thread_info=(get_thread_info)();
         return local_thread_info?(detail::win32::handle)local_thread_info->thread_handle:detail::win32::invalid_handle_value;
     }
 
-    detail::thread_data_ptr thread::get_thread_info() const
+    detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const
     {
-        boost::mutex::scoped_lock l(thread_info_mutex);
         return thread_info;
     }
 
@@ -542,8 +551,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;
         }
 
@@ -585,10 +594,11 @@ namespace boost
                 current_node->func=func;
                 current_node->value=tss_data;
             }
-            else
+            else if(func && tss_data)
             {
                 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

@@ -38,11 +38,17 @@ namespace {
     }
 }
 
+#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;
+}
+#else
 extern "C" {
 
-    void (* after_ctors )(void) __attribute__((section(".ctors")))     = boost::on_process_enter;
-    void (* before_dtors)(void) __attribute__((section(".dtors")))     = boost::on_thread_exit;
-    void (* after_dtors )(void) __attribute__((section(".dtors.zzz"))) = boost::on_process_exit;
+    void (* after_ctors )() __attribute__((section(".ctors")))     = boost::on_process_enter;
+    void (* before_dtors)() __attribute__((section(".dtors")))     = boost::on_thread_exit;
+    void (* after_dtors )() __attribute__((section(".dtors.zzz"))) = boost::on_process_exit;
 
     ULONG __tls_index__ = 0;
     char __tls_end__ __attribute__((section(".tls$zzz"))) = 0;
@@ -50,10 +56,8 @@ extern "C" {
 
 
     PIMAGE_TLS_CALLBACK __crt_xl_start__ __attribute__ ((section(".CRT$XLA"))) = 0;
-    PIMAGE_TLS_CALLBACK __crt_xl_tls_callback__ __attribute__ ((section(".CRT$XLB"))) = on_tls_callback;
     PIMAGE_TLS_CALLBACK __crt_xl_end__ __attribute__ ((section(".CRT$XLZ"))) = 0;
 }
-
 extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata$T"))) =
 {
         (DWORD) &__tls_start__,
@@ -63,6 +67,7 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
         (DWORD) 0,
         (DWORD) 0
 };
+#endif
 
 
 #elif  defined(_MSC_VER) && !defined(UNDER_CE)
@@ -77,13 +82,13 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
     //Definitions required by implementation
 
     #if (_MSC_VER < 1300) // 1300 == VC++ 7.0
-        typedef void (__cdecl *_PVFV)(void);
+        typedef void (__cdecl *_PVFV)();
         #define INIRETSUCCESS
-        #define PVAPI void
+        #define PVAPI void __cdecl
     #else
-        typedef int (__cdecl *_PVFV)(void);
+        typedef int (__cdecl *_PVFV)();
         #define INIRETSUCCESS 0
-        #define PVAPI int
+        #define PVAPI int __cdecl
     #endif
 
     typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);
@@ -100,9 +105,9 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
     {
         //Forward declarations
 
-        static PVAPI on_tls_prepare(void);
-        static PVAPI on_process_init(void);
-        static PVAPI on_process_term(void);
+        static PVAPI on_tls_prepare();
+        static PVAPI on_process_init();
+        static PVAPI on_process_term();
         static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);
 
         //The .CRT$Xxx information is taken from Codeguru:
@@ -157,7 +162,7 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma warning(disable:4189)
 #endif
 
-        PVAPI on_tls_prepare(void)
+        PVAPI on_tls_prepare()
         {
             //The following line has an important side effect:
             //if the TLS directory is not already there, it will
@@ -198,7 +203,7 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #pragma warning(pop)
 #endif
 
-        PVAPI on_process_init(void)
+        PVAPI on_process_init()
         {
             //Schedule on_thread_exit() to be called for the main
             //thread before destructors of global objects have been
@@ -218,7 +223,7 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
             return INIRETSUCCESS;
         }
 
-        PVAPI on_process_term(void)
+        PVAPI on_process_term()
         {
             boost::on_process_exit();
             return INIRETSUCCESS;

test/test_futures.cpp

@@ -18,7 +18,7 @@
     template<typename T>
     typename boost::remove_reference<T>::type&& cast_to_rval(T&& t)
     {
-        return t;
+        return static_cast<typename boost::remove_reference<T>::type&&>(t);
     }
 #else
     template<typename T>
@@ -556,7 +556,7 @@ void wait_callback(boost::promise<int>& pi)
     }
 }
 
-void do_nothing_callback(boost::promise<int>& pi)
+void do_nothing_callback(boost::promise<int>& /*pi*/)
 {
     boost::lock_guard<boost::mutex> lk(callback_mutex);
     ++callback_called;
@@ -1041,6 +1041,8 @@ void test_wait_for_any_from_range()
         }
         boost::thread(::cast_to_rval(tasks[i]));
     
+        BOOST_CHECK(boost::wait_for_any(futures,futures)==futures);
+        
         boost::unique_future<int>* const future=boost::wait_for_any(futures,futures+count);
     
         BOOST_CHECK(future==(futures+i));

test/test_shared_mutex_part_2.cpp

@@ -138,6 +138,14 @@ void test_can_lock_upgrade_if_currently_locked_shared()
     CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,reader_count+1);
 }
 
+void test_can_lock_upgrade_to_unique_if_currently_locked_upgrade()
+{
+    boost::shared_mutex mtx;
+    boost::upgrade_lock<boost::shared_mutex> l(mtx);
+    boost::upgrade_to_unique_lock<boost::shared_mutex> ul(l);
+    BOOST_CHECK(ul.owns_lock());
+}
+
 void test_if_other_thread_has_write_lock_try_lock_shared_returns_false()
 {
 
@@ -282,6 +290,7 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 
     test->add(BOOST_TEST_CASE(&test_only_one_upgrade_lock_permitted));
     test->add(BOOST_TEST_CASE(&test_can_lock_upgrade_if_currently_locked_shared));
+    test->add(BOOST_TEST_CASE(&test_can_lock_upgrade_to_unique_if_currently_locked_upgrade));
     test->add(BOOST_TEST_CASE(&test_if_other_thread_has_write_lock_try_lock_shared_returns_false));
     test->add(BOOST_TEST_CASE(&test_if_no_thread_has_lock_try_lock_shared_returns_true));
     test->add(BOOST_TEST_CASE(&test_if_other_thread_has_shared_lock_try_lock_shared_returns_true));