passenger 4.0.20 → 4.0.21

data/ext/boost/thread/pthread/once_atomic.hpp

@@ -0,0 +1,313 @@
+#ifndef BOOST_THREAD_PTHREAD_ONCE_ATOMIC_HPP
+#define BOOST_THREAD_PTHREAD_ONCE_ATOMIC_HPP
+
+//  once.hpp
+//
+//  (C) Copyright 2013 Andrey Semashev
+//  (C) Copyright 2013 Vicente J. Botet Escriba
+//
+//  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/detail/config.hpp>
+
+#include <boost/cstdint.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/detail/invoke.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/bind.hpp>
+#include <boost/atomic.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+
+  struct once_flag;
+
+  namespace thread_detail
+  {
+
+#if BOOST_ATOMIC_INT_LOCK_FREE == 2
+    typedef unsigned int atomic_int_type;
+#elif BOOST_ATOMIC_SHORT_LOCK_FREE == 2
+    typedef unsigned short atomic_int_type;
+#elif BOOST_ATOMIC_CHAR_LOCK_FREE == 2
+    typedef unsigned char atomic_int_type;
+#elif BOOST_ATOMIC_LONG_LOCK_FREE == 2
+    typedef unsigned long atomic_int_type;
+#elif defined(BOOST_HAS_LONG_LONG) && BOOST_ATOMIC_LLONG_LOCK_FREE == 2
+    typedef ulong_long_type atomic_int_type;
+#else
+    // All tested integer types are not atomic, the spinlock pool will be used
+    typedef unsigned int atomic_int_type;
+#endif
+
+    typedef boost::atomic<atomic_int_type> atomic_type;
+
+    BOOST_THREAD_DECL bool enter_once_region(once_flag& flag) BOOST_NOEXCEPT;
+    BOOST_THREAD_DECL void commit_once_region(once_flag& flag) BOOST_NOEXCEPT;
+    BOOST_THREAD_DECL void rollback_once_region(once_flag& flag) BOOST_NOEXCEPT;
+    inline atomic_type& get_atomic_storage(once_flag& flag)  BOOST_NOEXCEPT;
+  }
+
+#ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11
+
+  struct once_flag
+  {
+    BOOST_THREAD_NO_COPYABLE(once_flag)
+    BOOST_CONSTEXPR once_flag() BOOST_NOEXCEPT : storage(0)
+    {
+    }
+
+  private:
+    thread_detail::atomic_type storage;
+
+    friend BOOST_THREAD_DECL bool thread_detail::enter_once_region(once_flag& flag) BOOST_NOEXCEPT;
+    friend BOOST_THREAD_DECL void thread_detail::commit_once_region(once_flag& flag) BOOST_NOEXCEPT;
+    friend BOOST_THREAD_DECL void thread_detail::rollback_once_region(once_flag& flag) BOOST_NOEXCEPT;
+    friend thread_detail::atomic_type& thread_detail::get_atomic_storage(once_flag& flag) BOOST_NOEXCEPT;
+  };
+
+#define BOOST_ONCE_INIT boost::once_flag()
+
+  namespace thread_detail
+  {
+    inline atomic_type& get_atomic_storage(once_flag& flag) BOOST_NOEXCEPT
+    {
+      //return reinterpret_cast< atomic_type& >(flag.storage);
+      return flag.storage;
+    }
+  }
+
+#else // BOOST_THREAD_PROVIDES_ONCE_CXX11
+  struct once_flag
+  {
+    // The thread_detail::atomic_int_type storage is marked
+    // with this attribute in order to let the compiler know that it will alias this member
+    // and silence compilation warnings.
+    BOOST_THREAD_ATTRIBUTE_MAY_ALIAS thread_detail::atomic_int_type storage;
+  };
+
+  #define BOOST_ONCE_INIT {0}
+
+  namespace thread_detail
+  {
+    inline atomic_type& get_atomic_storage(once_flag& flag) BOOST_NOEXCEPT
+    {
+      return reinterpret_cast< atomic_type& >(flag.storage);
+    }
+
+  }
+
+#endif // BOOST_THREAD_PROVIDES_ONCE_CXX11
+
+#if defined BOOST_THREAD_PROVIDES_INVOKE
+#define BOOST_THREAD_INVOKE_RET_VOID detail::invoke
+#define BOOST_THREAD_INVOKE_RET_VOID_CALL
+#elif defined BOOST_THREAD_PROVIDES_INVOKE_RET
+#define BOOST_THREAD_INVOKE_RET_VOID detail::invoke<void>
+#define BOOST_THREAD_INVOKE_RET_VOID_CALL
+#else
+#define BOOST_THREAD_INVOKE_RET_VOID boost::bind
+#define BOOST_THREAD_INVOKE_RET_VOID_CALL ()
+#endif
+
+
+#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+  template<typename Function, class ...ArgTypes>
+  inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f, BOOST_THREAD_RV_REF(ArgTypes)... args)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        BOOST_THREAD_INVOKE_RET_VOID(
+                        thread_detail::decay_copy(boost::forward<Function>(f)),
+                        thread_detail::decay_copy(boost::forward<ArgTypes>(args))...
+        ) BOOST_THREAD_INVOKE_RET_VOID_CALL;
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+#else
+  template<typename Function>
+  inline void call_once(once_flag& flag, Function f)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        f();
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+
+  template<typename Function, typename T1>
+  inline void call_once(once_flag& flag, Function f, T1 p1)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        BOOST_THREAD_INVOKE_RET_VOID(f, p1) BOOST_THREAD_INVOKE_RET_VOID_CALL;
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+
+  template<typename Function, typename T1, typename T2>
+  inline void call_once(once_flag& flag, Function f, T1 p1, T2 p2)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        BOOST_THREAD_INVOKE_RET_VOID(f, p1, p2) BOOST_THREAD_INVOKE_RET_VOID_CALL;
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+
+  template<typename Function, typename T1, typename T2, typename T3>
+  inline void call_once(once_flag& flag, Function f, T1 p1, T2 p2, T3 p3)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        BOOST_THREAD_INVOKE_RET_VOID(f, p1, p2, p3) BOOST_THREAD_INVOKE_RET_VOID_CALL;
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+
+  template<typename Function>
+  inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        f();
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+
+  template<typename Function, typename T1>
+  inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f, BOOST_THREAD_RV_REF(T1) p1)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        BOOST_THREAD_INVOKE_RET_VOID(
+            thread_detail::decay_copy(boost::forward<Function>(f)),
+            thread_detail::decay_copy(boost::forward<T1>(p1))
+        ) BOOST_THREAD_INVOKE_RET_VOID_CALL;
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+  template<typename Function, typename T1, typename T2>
+  inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f, BOOST_THREAD_RV_REF(T1) p1, BOOST_THREAD_RV_REF(T2) p2)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        BOOST_THREAD_INVOKE_RET_VOID(
+            thread_detail::decay_copy(boost::forward<Function>(f)),
+            thread_detail::decay_copy(boost::forward<T1>(p1)),
+            thread_detail::decay_copy(boost::forward<T1>(p2))
+        ) BOOST_THREAD_INVOKE_RET_VOID_CALL;
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+  template<typename Function, typename T1, typename T2, typename T3>
+  inline void call_once(once_flag& flag, BOOST_THREAD_RV_REF(Function) f, BOOST_THREAD_RV_REF(T1) p1, BOOST_THREAD_RV_REF(T2) p2, BOOST_THREAD_RV_REF(T3) p3)
+  {
+    if (thread_detail::enter_once_region(flag))
+    {
+      BOOST_TRY
+      {
+        BOOST_THREAD_INVOKE_RET_VOID(
+            thread_detail::decay_copy(boost::forward<Function>(f)),
+            thread_detail::decay_copy(boost::forward<T1>(p1)),
+            thread_detail::decay_copy(boost::forward<T1>(p2)),
+            thread_detail::decay_copy(boost::forward<T1>(p3))
+        ) BOOST_THREAD_INVOKE_RET_VOID_CALL;
+
+      }
+      BOOST_CATCH (...)
+      {
+        thread_detail::rollback_once_region(flag);
+        BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+      thread_detail::commit_once_region(flag);
+    }
+  }
+
+
+
+#endif
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif
+

data/ext/boost/thread/pthread/recursive_mutex.hpp

@@ -9,7 +9,9 @@
 #include <pthread.h>
 #include <boost/throw_exception.hpp>
 #include <boost/thread/exceptions.hpp>
-#include <boost/thread/locks.hpp>
+#if defined BOOST_THREAD_PROVIDES_NESTED_LOCKS
+#include <boost/thread/lock_types.hpp>
+#endif
 #include <boost/thread/thread_time.hpp>
 #include <boost/assert.hpp>
 #ifndef _WIN32
@@ -26,10 +28,13 @@
 #include <boost/thread/detail/delete.hpp>
 
 #ifdef _POSIX_TIMEOUTS
-#if _POSIX_TIMEOUTS >= 0
+#if _POSIX_TIMEOUTS >= 0 && _POSIX_TIMEOUTS>=200112L
+#ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
 #define BOOST_PTHREAD_HAS_TIMEDLOCK
 #endif
 #endif
+#endif
+
 
 #if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE) && defined(BOOST_PTHREAD_HAS_TIMEDLOCK)
 #define BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
@@ -167,8 +172,10 @@ namespace boost
 
 #endif
 
+#if defined BOOST_THREAD_PROVIDES_NESTED_LOCKS
         typedef unique_lock<recursive_mutex> scoped_lock;
         typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
+#endif
     };
 
     typedef recursive_mutex recursive_try_mutex;
@@ -232,11 +239,13 @@ namespace boost
 #endif
         }
 
+#if defined BOOST_THREAD_USES_DATETIME
         template<typename TimeDuration>
         bool timed_lock(TimeDuration const & relative_time)
         {
             return timed_lock(get_system_time()+relative_time);
         }
+#endif
 
 #ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
         void lock()
@@ -334,12 +343,13 @@ namespace boost
 
 #endif
 
+#if defined BOOST_THREAD_USES_DATETIME
         bool timed_lock(system_time const & abs_time)
         {
-            struct timespec const ts=detail::get_timespec(abs_time);
+            struct timespec const ts=detail::to_timespec(abs_time);
             return do_try_lock_until(ts);
         }
-
+#endif
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class Rep, class Period>
         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
@@ -363,12 +373,9 @@ namespace boost
         }
         bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
         {
-          using namespace chrono;
-          nanoseconds d = tp.time_since_epoch();
-          timespec ts;
-          seconds s = duration_cast<seconds>(d);
-          ts.tv_sec = static_cast<long>(s.count());
-          ts.tv_nsec = static_cast<long>((d - s).count());
+          //using namespace chrono;
+          chrono::nanoseconds d = tp.time_since_epoch();
+          timespec ts = boost::detail::to_timespec(d);
           return do_try_lock_until(ts);
         }
 #endif
@@ -380,9 +387,11 @@ namespace boost
             return &m;
         }
 
+#if defined BOOST_THREAD_PROVIDES_NESTED_LOCKS
         typedef unique_lock<recursive_timed_mutex> scoped_timed_lock;
         typedef detail::try_lock_wrapper<recursive_timed_mutex> scoped_try_lock;
         typedef scoped_timed_lock scoped_lock;
+#endif
     };
 
 }

data/ext/boost/thread/pthread/shared_mutex.hpp

@@ -12,12 +12,15 @@
 #include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
 #include <boost/thread/detail/thread_interruption.hpp>
+#endif
 #ifdef BOOST_THREAD_USES_CHRONO
 #include <boost/chrono/system_clocks.hpp>
 #include <boost/chrono/ceil.hpp>
 #endif
 #include <boost/thread/detail/delete.hpp>
+#include <boost/assert.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -26,8 +29,125 @@ namespace boost
     class shared_mutex
     {
     private:
-        struct state_data
+        class state_data
         {
+        public:
+            state_data () :
+              shared_count(0),
+              exclusive(false),
+              upgrade(false),
+              exclusive_waiting_blocked(false)
+            {}
+
+            void assert_free() const
+            {
+                BOOST_ASSERT( ! exclusive );
+                BOOST_ASSERT( ! upgrade );
+                BOOST_ASSERT( shared_count==0 );
+            }
+
+            void assert_locked() const
+            {
+                BOOST_ASSERT( exclusive );
+                BOOST_ASSERT( shared_count==0 );
+                BOOST_ASSERT( ! upgrade );
+            }
+
+            void assert_lock_shared () const
+            {
+                BOOST_ASSERT( ! exclusive );
+                BOOST_ASSERT( shared_count>0 );
+                //BOOST_ASSERT( (! upgrade) || (shared_count>1));
+                // if upgraded there are at least 2 threads sharing the mutex,
+                // except when unlock_upgrade_and_lock has decreased the number of readers but has not taken yet exclusive ownership.
+            }
+
+            void assert_lock_upgraded () const
+            {
+                BOOST_ASSERT( ! exclusive );
+                BOOST_ASSERT(  upgrade );
+                BOOST_ASSERT(  shared_count>0 );
+            }
+
+            void assert_lock_not_upgraded () const
+            {
+                BOOST_ASSERT(  ! upgrade );
+            }
+
+            bool can_lock () const
+            {
+                return ! (shared_count || exclusive);
+            }
+
+            void exclusive_blocked (bool blocked)
+            {
+                exclusive_waiting_blocked = blocked;
+            }
+
+            void lock ()
+            {
+                exclusive = true;
+            }
+
+            void unlock ()
+            {
+                exclusive = false;
+                exclusive_waiting_blocked = false;
+            }
+
+            bool can_lock_shared () const
+            {
+                return ! (exclusive || exclusive_waiting_blocked);
+            }
+
+            bool more_shared () const
+            {
+                return shared_count > 0 ;
+            }
+            unsigned get_shared_count () const
+            {
+                return shared_count ;
+            }
+            unsigned  lock_shared ()
+            {
+                return ++shared_count;
+            }
+
+
+            void unlock_shared ()
+            {
+                --shared_count;
+            }
+
+            bool unlock_shared_downgrades()
+            {
+                  if (upgrade) {
+                      upgrade=false;
+                      exclusive=true;
+                      return true;
+                  } else {
+                      exclusive_waiting_blocked=false;
+                      return false;
+                  }
+            }
+
+            void lock_upgrade ()
+            {
+                ++shared_count;
+                upgrade=true;
+            }
+            bool can_lock_upgrade () const
+            {
+                return ! (exclusive || exclusive_waiting_blocked || upgrade);
+            }
+
+            void unlock_upgrade ()
+            {
+                upgrade=false;
+                --shared_count;
+            }
+
+        //private:
             unsigned shared_count;
             bool exclusive;
             bool upgrade;
@@ -49,12 +169,11 @@ namespace boost
         }
 
     public:
+
         BOOST_THREAD_NO_COPYABLE(shared_mutex)
 
         shared_mutex()
         {
-            state_data state_={0,0,0,0};
-            state=state_;
         }
 
         ~shared_mutex()
@@ -63,44 +182,45 @@ namespace boost
 
         void lock_shared()
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
-
-            while(state.exclusive || state.exclusive_waiting_blocked)
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+            while(!state.can_lock_shared())
             {
                 shared_cond.wait(lk);
             }
-            ++state.shared_count;
+            state.lock_shared();
         }
 
         bool try_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::unique_lock<boost::mutex> lk(state_change);
 
-            if(state.exclusive || state.exclusive_waiting_blocked)
+            if(!state.can_lock_shared())
             {
                 return false;
             }
-            else
-            {
-                ++state.shared_count;
-                return true;
-            }
+            state.lock_shared();
+            return true;
         }
 
+#if defined BOOST_THREAD_USES_DATETIME
         bool timed_lock_shared(system_time const& timeout)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
 
-            while(state.exclusive || state.exclusive_waiting_blocked)
+            while(!state.can_lock_shared())
             {
                 if(!shared_cond.timed_wait(lk,timeout))
                 {
                     return false;
                 }
             }
-            ++state.shared_count;
+            state.lock_shared();
             return true;
         }
 
@@ -109,6 +229,7 @@ namespace boost
         {
             return timed_lock_shared(get_system_time()+relative_time);
         }
+#endif
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class Rep, class Period>
         bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
@@ -118,36 +239,43 @@ namespace boost
         template <class Clock, class Duration>
         bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
           boost::this_thread::disable_interruption do_not_disturb;
-          boost::mutex::scoped_lock lk(state_change);
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
 
-          while(state.exclusive || state.exclusive_waiting_blocked)
+          while(!state.can_lock_shared())
+          //while(state.exclusive || state.exclusive_waiting_blocked)
           {
               if(cv_status::timeout==shared_cond.wait_until(lk,abs_time))
               {
                   return false;
               }
           }
-          ++state.shared_count;
+          state.lock_shared();
           return true;
         }
 #endif
         void unlock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
-            bool const last_reader=!--state.shared_count;
-
-            if(last_reader)
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_lock_shared();
+            state.unlock_shared();
+            if (! state.more_shared())
             {
-                if(state.upgrade)
+                if (state.upgrade)
                 {
+                    // As there is a thread doing a unlock_upgrade_and_lock that is waiting for ! state.more_shared()
+                    // avoid other threads to lock, lock_upgrade or lock_shared, so only this thread is notified.
                     state.upgrade=false;
                     state.exclusive=true;
+                    lk.unlock();
                     upgrade_cond.notify_one();
                 }
                 else
                 {
                     state.exclusive_waiting_blocked=false;
+                    lk.unlock();
                 }
                 release_waiters();
             }
@@ -155,10 +283,12 @@ namespace boost
 
         void lock()
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
 
-            while(state.shared_count || state.exclusive)
+            while (state.shared_count || state.exclusive)
             {
                 state.exclusive_waiting_blocked=true;
                 exclusive_cond.wait(lk);
@@ -166,10 +296,13 @@ namespace boost
             state.exclusive=true;
         }
 
+#if defined BOOST_THREAD_USES_DATETIME
         bool timed_lock(system_time const& timeout)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
 
             while(state.shared_count || state.exclusive)
             {
@@ -194,7 +327,7 @@ namespace boost
         {
             return timed_lock(get_system_time()+relative_time);
         }
-
+#endif
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class Rep, class Period>
         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
@@ -204,8 +337,10 @@ namespace boost
         template <class Clock, class Duration>
         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
           boost::this_thread::disable_interruption do_not_disturb;
-          boost::mutex::scoped_lock lk(state_change);
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
 
           while(state.shared_count || state.exclusive)
           {
@@ -228,7 +363,7 @@ namespace boost
 
         bool try_lock()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::unique_lock<boost::mutex> lk(state_change);
 
             if(state.shared_count || state.exclusive)
             {
@@ -244,28 +379,35 @@ namespace boost
 
         void unlock()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_locked();
             state.exclusive=false;
             state.exclusive_waiting_blocked=false;
+            state.assert_free();
             release_waiters();
         }
 
         void lock_upgrade()
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
             while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
                 shared_cond.wait(lk);
             }
-            ++state.shared_count;
+            state.lock_shared();
             state.upgrade=true;
         }
 
+#if defined BOOST_THREAD_USES_DATETIME
         bool timed_lock_upgrade(system_time const& timeout)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
             while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
                 if(!shared_cond.timed_wait(lk,timeout))
@@ -277,7 +419,7 @@ namespace boost
                     break;
                 }
             }
-            ++state.shared_count;
+            state.lock_shared();
             state.upgrade=true;
             return true;
         }
@@ -287,7 +429,7 @@ namespace boost
         {
             return timed_lock_upgrade(get_system_time()+relative_time);
         }
-
+#endif
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class Rep, class Period>
         bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time)
@@ -297,8 +439,10 @@ namespace boost
         template <class Clock, class Duration>
         bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
           boost::this_thread::disable_interruption do_not_disturb;
-          boost::mutex::scoped_lock lk(state_change);
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
           while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
           {
               if(cv_status::timeout == shared_cond.wait_until(lk,abs_time))
@@ -310,68 +454,75 @@ namespace boost
                   break;
               }
           }
-          ++state.shared_count;
+          state.lock_shared();
           state.upgrade=true;
           return true;
         }
 #endif
         bool try_lock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::unique_lock<boost::mutex> lk(state_change);
             if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
             {
                 return false;
             }
             else
             {
-                ++state.shared_count;
+                state.lock_shared();
                 state.upgrade=true;
+                state.assert_lock_upgraded();
                 return true;
             }
         }
 
         void unlock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
-            state.upgrade=false;
-            bool const last_reader=!--state.shared_count;
-
-            if(last_reader)
+            boost::unique_lock<boost::mutex> lk(state_change);
+            //state.upgrade=false;
+            state.unlock_upgrade();
+            if(! state.more_shared() )
             {
                 state.exclusive_waiting_blocked=false;
                 release_waiters();
             } else {
-              shared_cond.notify_all();
+                shared_cond.notify_all();
             }
         }
 
         // Upgrade <-> Exclusive
         void unlock_upgrade_and_lock()
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             boost::this_thread::disable_interruption do_not_disturb;
-            boost::mutex::scoped_lock lk(state_change);
-            --state.shared_count;
-            while(state.shared_count)
+#endif
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_lock_upgraded();
+            state.unlock_shared();
+            while (state.more_shared())
             {
                 upgrade_cond.wait(lk);
             }
             state.upgrade=false;
             state.exclusive=true;
+            state.assert_locked();
         }
 
         void unlock_and_lock_upgrade()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_locked();
             state.exclusive=false;
             state.upgrade=true;
-            ++state.shared_count;
+            state.lock_shared();
             state.exclusive_waiting_blocked=false;
+            state.assert_lock_upgraded();
             release_waiters();
         }
 
         bool try_unlock_upgrade_and_lock()
         {
-          boost::mutex::scoped_lock lk(state_change);
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_upgraded();
           if(    !state.exclusive
               && !state.exclusive_waiting_blocked
               && state.upgrade
@@ -380,6 +531,7 @@ namespace boost
             state.shared_count=0;
             state.exclusive=true;
             state.upgrade=false;
+            state.assert_locked();
             return true;
           }
           return false;
@@ -398,8 +550,11 @@ namespace boost
         try_unlock_upgrade_and_lock_until(
                           const chrono::time_point<Clock, Duration>& abs_time)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
           boost::this_thread::disable_interruption do_not_disturb;
-          boost::mutex::scoped_lock lk(state_change);
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_upgraded();
           if (state.shared_count != 1)
           {
               for (;;)
@@ -422,9 +577,10 @@ namespace boost
         // Shared <-> Exclusive
         void unlock_and_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_locked();
             state.exclusive=false;
-            ++state.shared_count;
+            state.lock_shared();
             state.exclusive_waiting_blocked=false;
             release_waiters();
         }
@@ -432,7 +588,8 @@ namespace boost
 #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
         bool try_unlock_shared_and_lock()
         {
-          boost::mutex::scoped_lock lk(state_change);
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_shared();
           if(    !state.exclusive
               && !state.exclusive_waiting_blocked
               && !state.upgrade
@@ -458,8 +615,11 @@ namespace boost
             try_unlock_shared_and_lock_until(
                           const chrono::time_point<Clock, Duration>& abs_time)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
           boost::this_thread::disable_interruption do_not_disturb;
-          boost::mutex::scoped_lock lk(state_change);
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_shared();
           if (state.shared_count != 1)
           {
               for (;;)
@@ -483,7 +643,8 @@ namespace boost
         // Shared <-> Upgrade
         void unlock_upgrade_and_lock_shared()
         {
-            boost::mutex::scoped_lock lk(state_change);
+            boost::unique_lock<boost::mutex> lk(state_change);
+            state.assert_lock_upgraded();
             state.upgrade=false;
             state.exclusive_waiting_blocked=false;
             release_waiters();
@@ -492,7 +653,8 @@ namespace boost
 #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
         bool try_unlock_shared_and_lock_upgrade()
         {
-          boost::mutex::scoped_lock lk(state_change);
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_shared();
           if(    !state.exclusive
               && !state.exclusive_waiting_blocked
               && !state.upgrade
@@ -517,8 +679,11 @@ namespace boost
             try_unlock_shared_and_lock_upgrade_until(
                           const chrono::time_point<Clock, Duration>& abs_time)
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
           boost::this_thread::disable_interruption do_not_disturb;
-          boost::mutex::scoped_lock lk(state_change);
+#endif
+          boost::unique_lock<boost::mutex> lk(state_change);
+          state.assert_lock_shared();
           if(    state.exclusive
               || state.exclusive_waiting_blocked
               || state.upgrade