passenger 4.0.20 → 4.0.21

data/ext/boost/libs/atomic/lockpool.cpp

@@ -0,0 +1,24 @@
+#include <boost/atomic.hpp>
+
+//  Copyright (c) 2011 Helge Bahmann
+//
+//  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)
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
+static lockpool::lock_type lock_pool_[41];
+
+// NOTE: This function must NOT be inline. Otherwise MSVC 9 will sometimes generate broken code for modulus operation which result in crashes.
+BOOST_ATOMIC_DECL lockpool::lock_type& lockpool::get_lock_for(const volatile void* addr)
+{
+    std::size_t index = reinterpret_cast<std::size_t>(addr) % (sizeof(lock_pool_) / sizeof(*lock_pool_));
+    return lock_pool_[index];
+}
+
+}
+}
+}

data/ext/boost/libs/system/src/error_code.cpp

@@ -22,9 +22,6 @@
 #include <cstdlib>
 #include <cassert>
 
-using namespace boost::system;
-using namespace boost::system::errc;
-
 #include <cstring> // for strerror/strerror_r
 
 # if defined( BOOST_WINDOWS_API )
@@ -36,19 +33,21 @@ using namespace boost::system::errc;
 # endif
 
 //----------------------------------------------------------------------------//
+namespace boost
+{
+    namespace system
+    {
 
 namespace
 {
-#if defined(__PGI)
-  using boost::system::errc::invalid_argument;
-#endif
+    
   //  standard error categories  ---------------------------------------------//
 
   class generic_error_category : public error_category
   {
   public:
     generic_error_category(){}
-    const char *   name() const;
+    const char *   name() const BOOST_SYSTEM_NOEXCEPT;
     std::string    message( int ev ) const;
   };
 
@@ -56,20 +55,25 @@ namespace
   {
   public:
     system_error_category(){}
-    const char *        name() const;
+    const char *        name() const BOOST_SYSTEM_NOEXCEPT;
     std::string         message( int ev ) const;
-    error_condition     default_error_condition( int ev ) const;
+    error_condition     default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT;
   };
 
   //  generic_error_category implementation  ---------------------------------//
 
-  const char * generic_error_category::name() const
+  const char * generic_error_category::name() const BOOST_SYSTEM_NOEXCEPT
   {
     return "generic";
   }
 
   std::string generic_error_category::message( int ev ) const
   {
+    using namespace boost::system::errc;
+#if defined(__PGI)
+      using boost::system::errc::invalid_argument;
+#endif
+      
     static std::string unknown_err( "Unknown error" );
   // strerror_r is preferred because it is always thread safe,
   // however, we fallback to strerror in certain cases because:
@@ -133,7 +137,9 @@ namespace
         }
       }
       std::string msg;
+#   ifndef BOOST_NO_EXCEPTIONS
       try
+#   endif
       {
         msg = ( ( result == invalid_argument ) ? "Unknown error" : bp );
       }
@@ -154,13 +160,18 @@ namespace
   }
   //  system_error_category implementation  --------------------------------// 
 
-  const char * system_error_category::name() const
+  const char * system_error_category::name() const BOOST_SYSTEM_NOEXCEPT
   {
     return "system";
   }
 
-  error_condition system_error_category::default_error_condition( int ev ) const
+  error_condition system_error_category::default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
   {
+    using namespace boost::system::errc;
+#if defined(__PGI)
+      using boost::system::errc::invalid_argument;
+#endif
+
     switch ( ev )
     {
     case 0: return make_error_condition( success );
@@ -401,10 +412,6 @@ namespace
 
 } // unnamed namespace
 
-namespace boost
-{
-  namespace system
-  {
 
 # ifndef BOOST_SYSTEM_NO_DEPRECATED
     BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code;
@@ -414,13 +421,13 @@ namespace boost
                                          //  address for comparison purposes
 # endif
 
-    BOOST_SYSTEM_DECL const error_category & system_category()
+    BOOST_SYSTEM_DECL const error_category & system_category() BOOST_SYSTEM_NOEXCEPT
     {
       static const system_error_category  system_category_const;
       return system_category_const;
     }
 
-    BOOST_SYSTEM_DECL const error_category & generic_category()
+    BOOST_SYSTEM_DECL const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
     {
       static const generic_error_category generic_category_const;
       return generic_category_const;

data/ext/boost/libs/thread/src/future.cpp

@@ -7,7 +7,7 @@
 #ifndef BOOST_NO_EXCEPTIONS
 
 
-#include <boost/thread/future.hpp>
+#include <boost/thread/future_error_code.hpp>
 
 namespace boost
 {
@@ -19,12 +19,12 @@ namespace boost
       public boost::system::error_category
     {
     public:
-        virtual const char* name() const; //BOOST_NOEXCEPT;
+        virtual const char* name() const BOOST_NOEXCEPT;
         virtual std::string message(int ev) const;
     };
 
     const char*
-    future_error_category::name() const //BOOST_NOEXCEPT
+    future_error_category::name() const BOOST_NOEXCEPT
     {
         return "future";
     }
@@ -48,14 +48,16 @@ namespace boost
         }
         return std::string("unspecified future_errc value\n");
     }
+    future_error_category future_error_category_var;
   }
 
+  BOOST_THREAD_DECL
   const system::error_category&
   future_category() BOOST_NOEXCEPT
   {
-      static thread_detail::future_error_category f;
-      return f;
+      return thread_detail::future_error_category_var;
   }
 
 }
 #endif
+

data/ext/boost/libs/thread/src/pthread/once.cpp

@@ -3,7 +3,12 @@
 //  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>
+#ifdef BOOST_THREAD_ONCE_ATOMIC
+#include "./once_atomic.cpp"
+#else
 #define __STDC_CONSTANT_MACROS
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 #include <boost/thread/once.hpp>
 #include <boost/assert.hpp>
 #include <pthread.h>
@@ -12,9 +17,9 @@
 
 namespace boost
 {
-    namespace detail
+    namespace thread_detail
     {
-        BOOST_THREAD_DECL thread_detail::uintmax_atomic_t once_global_epoch=BOOST_THREAD_DETAIL_UINTMAX_ATOMIC_MAX_C;
+        BOOST_THREAD_DECL uintmax_atomic_t once_global_epoch=BOOST_THREAD_DETAIL_UINTMAX_ATOMIC_MAX_C;
         BOOST_THREAD_DECL pthread_mutex_t once_epoch_mutex=PTHREAD_MUTEX_INITIALIZER;
         BOOST_THREAD_DECL pthread_cond_t once_epoch_cv = PTHREAD_COND_INITIALIZER;
 
@@ -55,7 +60,7 @@ namespace boost
 #endif
         }
 
-        thread_detail::uintmax_atomic_t& get_once_per_thread_epoch()
+        uintmax_atomic_t& get_once_per_thread_epoch()
         {
             BOOST_VERIFY(!pthread_once(&epoch_tss_key_flag,create_epoch_tss_key));
             void* data=pthread_getspecific(epoch_tss_key);
@@ -70,3 +75,4 @@ namespace boost
     }
 
 }
+#endif //

data/ext/boost/libs/thread/src/pthread/once_atomic.cpp

@@ -0,0 +1,90 @@
+//  (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)
+
+//#define __STDC_CONSTANT_MACROS
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/once.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/atomic.hpp>
+#include <boost/memory_order.hpp>
+#include <pthread.h>
+
+namespace boost
+{
+  namespace thread_detail
+  {
+
+    enum flag_states
+    {
+      uninitialized, in_progress, initialized
+    };
+
+
+#ifndef BOOST_THREAD_PROVIDES_ONCE_CXX11
+    BOOST_STATIC_ASSERT_MSG(sizeof(atomic_int_type) == sizeof(atomic_type), "Boost.Thread: unsupported platform");
+#endif
+
+    static pthread_mutex_t once_mutex = PTHREAD_MUTEX_INITIALIZER;
+    static pthread_cond_t once_cv = PTHREAD_COND_INITIALIZER;
+
+    BOOST_THREAD_DECL bool enter_once_region(once_flag& flag) BOOST_NOEXCEPT
+    {
+      atomic_type& f = get_atomic_storage(flag);
+      if (f.load(memory_order_acquire) != initialized)
+      {
+        pthread::pthread_mutex_scoped_lock lk(&once_mutex);
+        if (f.load(memory_order_acquire) != initialized)
+        {
+          while (true)
+          {
+            atomic_int_type expected = uninitialized;
+            if (f.compare_exchange_strong(expected, in_progress, memory_order_acq_rel, memory_order_acquire))
+            {
+              // We have set the flag to in_progress
+              return true;
+            }
+            else if (expected == initialized)
+            {
+              // Another thread managed to complete the initialization
+              return false;
+            }
+            else
+            {
+              // Wait until the initialization is complete
+              //pthread::pthread_mutex_scoped_lock lk(&once_mutex);
+              BOOST_VERIFY(!pthread_cond_wait(&once_cv, &once_mutex));
+            }
+          }
+        }
+      }
+      return false;
+    }
+
+    BOOST_THREAD_DECL void commit_once_region(once_flag& flag) BOOST_NOEXCEPT
+    {
+      atomic_type& f = get_atomic_storage(flag);
+      {
+        pthread::pthread_mutex_scoped_lock lk(&once_mutex);
+        f.store(initialized, memory_order_release);
+      }
+      BOOST_VERIFY(!pthread_cond_broadcast(&once_cv));
+    }
+
+    BOOST_THREAD_DECL void rollback_once_region(once_flag& flag) BOOST_NOEXCEPT
+    {
+      atomic_type& f = get_atomic_storage(flag);
+      {
+        pthread::pthread_mutex_scoped_lock lk(&once_mutex);
+        f.store(uninitialized, memory_order_release);
+      }
+      BOOST_VERIFY(!pthread_cond_broadcast(&once_cv));
+    }
+
+  } // namespace thread_detail
+
+} // namespace boost

data/ext/boost/libs/thread/src/pthread/thread.cpp

@@ -1,20 +1,22 @@
 // Copyright (C) 2001-2003
 // William E. Kempf
 // Copyright (C) 2007-8 Anthony Williams
-// (C) Copyright 2011 Vicente J. Botet Escriba
+// (C) Copyright 2011-2012 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/thread/thread.hpp>
+#include <boost/thread/thread_only.hpp>
+#if defined BOOST_THREAD_USES_DATETIME
 #include <boost/thread/xtime.hpp>
+#endif
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/locks.hpp>
 #include <boost/thread/once.hpp>
 #include <boost/thread/tss.hpp>
-#include <boost/throw_exception.hpp>
+#include <boost/thread/future.hpp>
 
 #ifdef __GLIBC__
 #include <sys/sysinfo.h>
@@ -33,14 +35,17 @@ namespace boost
     {
         thread_data_base::~thread_data_base()
         {
-          {
             for (notify_list_t::iterator i = notify.begin(), e = notify.end();
                     i != e; ++i)
             {
                 i->second->unlock();
                 i->first->notify_all();
             }
-          }
+            for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
+                    i != e; ++i)
+            {
+                (*i)->make_ready();
+            }
         }
 
         struct thread_exit_callback_node
@@ -72,6 +77,7 @@ namespace boost
                     {
                         while(!thread_info->tss_data.empty() || thread_info->thread_exit_callbacks)
                         {
+
                             while(thread_info->thread_exit_callbacks)
                             {
                                 detail::thread_exit_callback_node* const current_node=thread_info->thread_exit_callbacks;
@@ -97,7 +103,10 @@ namespace boost
                                 thread_info->tss_data.erase(current);
                             }
                         }
-                        thread_info->self.reset();
+                        if (thread_info) // fixme: should we test this?
+                        {
+                          thread_info->self.reset();
+                        }
                     }
                 }
             }
@@ -148,26 +157,33 @@ namespace boost
                 boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->self;
                 thread_info->self.reset();
                 detail::set_current_thread_data(thread_info.get());
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 BOOST_TRY
                 {
+#endif
                     thread_info->run();
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+
                 }
                 BOOST_CATCH (thread_interrupted const&)
                 {
                 }
-                BOOST_CATCH_END
 // Removed as it stops the debugger identifying the cause of the exception
 // Unhandled exceptions still cause the application to terminate
 //                 BOOST_CATCH(...)
 //                 {
+//                   throw;
+//
 //                     std::terminate();
 //                 }
-
+                BOOST_CATCH_END
+#endif
                 detail::tls_destructor(thread_info.get());
                 detail::set_current_thread_data(0);
                 boost::lock_guard<boost::mutex> lock(thread_info->data_mutex);
                 thread_info->done=true;
                 thread_info->done_condition.notify_all();
+
                 return 0;
             }
         }
@@ -177,7 +193,9 @@ namespace boost
         {
             externally_launched_thread()
             {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 interrupt_enabled=false;
+#endif
             }
 
             void run()
@@ -215,18 +233,20 @@ namespace boost
     thread::thread() BOOST_NOEXCEPT
     {}
 
-    void thread::start_thread()
+    bool thread::start_thread_noexcept()
     {
         thread_info->self=thread_info;
         int const res = pthread_create(&thread_info->thread_handle, 0, &thread_proxy, thread_info.get());
         if (res != 0)
         {
             thread_info->self.reset();
-            boost::throw_exception(thread_resource_error(res, "boost thread: failed in pthread_create"));
+            return false;
+//            boost::throw_exception(thread_resource_error(res, "boost thread: failed in pthread_create"));
         }
+        return true;
     }
 
-    void thread::start_thread(const attributes& attr)
+    bool thread::start_thread_noexcept(const attributes& attr)
     {
         thread_info->self=thread_info;
         const attributes::native_handle_type* h = attr.native_handle();
@@ -234,14 +254,16 @@ namespace boost
         if (res != 0)
         {
             thread_info->self.reset();
-            boost::throw_exception(thread_resource_error());
+            return false;
+//            boost::throw_exception(thread_resource_error(res, "boost thread: failed in pthread_create"));
         }
         int detached_state;
         res = pthread_attr_getdetachstate(h, &detached_state);
         if (res != 0)
         {
             thread_info->self.reset();
-            boost::throw_exception(thread_resource_error());
+            return false;
+//            boost::throw_exception(thread_resource_error(res, "boost thread: failed in pthread_attr_getdetachstate"));
         }
         if (PTHREAD_CREATE_DETACHED==detached_state)
         {
@@ -259,6 +281,7 @@ namespace boost
               }
           }
         }
+        return true;
     }
 
 
@@ -268,12 +291,8 @@ namespace boost
         return thread_info;
     }
 
-    void thread::join()
+    bool thread::join_noexcept()
     {
-        if (this_thread::get_id() == get_id())
-        {
-            boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
-        }
         detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
@@ -312,21 +331,16 @@ namespace boost
             {
                 thread_info.reset();
             }
+            return true;
         }
         else
         {
-#ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
-          boost::throw_exception(thread_resource_error(system::errc::invalid_argument, "boost thread: thread not joinable"));
-#endif
+          return false;
         }
     }
 
-    bool thread::do_try_join_until(struct timespec const &timeout)
+    bool thread::do_try_join_until_noexcept(struct timespec const &timeout, bool& res)
     {
-        if (this_thread::get_id() == get_id())
-        {
-            boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
-        }
         detail::thread_data_ptr const local_thread_info=(get_thread_info)();
         if(local_thread_info)
         {
@@ -336,9 +350,10 @@ namespace boost
                 unique_lock<mutex> lock(local_thread_info->data_mutex);
                 while(!local_thread_info->done)
                 {
-                    if(!local_thread_info->done_condition.do_timed_wait(lock,timeout))
+                    if(!local_thread_info->done_condition.do_wait_until(lock,timeout))
                     {
-                        return false;
+                      res=false;
+                      return true;
                     }
                 }
                 do_join=!local_thread_info->join_started;
@@ -368,19 +383,18 @@ namespace boost
             {
                 thread_info.reset();
             }
+            res=true;
             return true;
         }
         else
         {
-#ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
-          boost::throw_exception(thread_resource_error(system::errc::invalid_argument, "boost thread: thread not joinable"));
-#endif
+          return false;
         }
     }
 
     bool thread::joinable() const BOOST_NOEXCEPT
     {
-        return (get_thread_info)();
+        return (get_thread_info)()?true:false;
     }
 
 
@@ -403,61 +417,104 @@ namespace boost
 
     namespace this_thread
     {
-
-#ifdef __DECXXX
-        /// Workaround of DECCXX issue of incorrect template substitution
-        template<>
-#endif
-        void sleep(const system_time& st)
+      namespace hiden
+      {
+        void BOOST_THREAD_DECL sleep_for(const timespec& ts)
         {
-            detail::thread_data_base* const thread_info=detail::get_current_thread_data();
+            boost::detail::thread_data_base* const thread_info=boost::detail::get_current_thread_data();
 
             if(thread_info)
             {
-                unique_lock<mutex> lk(thread_info->sleep_mutex);
-                while(thread_info->sleep_condition.timed_wait(lk,st)) {}
+              unique_lock<mutex> lk(thread_info->sleep_mutex);
+              while( thread_info->sleep_condition.do_wait_for(lk,ts)) {}
             }
             else
             {
-                xtime const xt=get_xtime(st);
 
+              if (boost::detail::timespec_ge(ts, boost::detail::timespec_zero()))
+              {
+
+  #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
+  #     if defined(__IBMCPP__)
+                BOOST_VERIFY(!pthread_delay_np(const_cast<timespec*>(&ts)));
+  #     else
+                BOOST_VERIFY(!pthread_delay_np(&ts));
+  #     endif
+  #   elif defined(BOOST_HAS_NANOSLEEP)
+                //  nanosleep takes a timespec that is an offset, not
+                //  an absolute time.
+                nanosleep(&ts, 0);
+  #   else
+                mutex mx;
+                unique_lock<mutex> lock(mx);
+                condition_variable cond;
+                cond.do_wait_for(lock, ts);
+  #   endif
+              }
+            }
+        }
+
+        void BOOST_THREAD_DECL sleep_until(const timespec& ts)
+        {
+            boost::detail::thread_data_base* const thread_info=boost::detail::get_current_thread_data();
+
+            if(thread_info)
+            {
+              unique_lock<mutex> lk(thread_info->sleep_mutex);
+              while(thread_info->sleep_condition.do_wait_until(lk,ts)) {}
+            }
+            else
+            {
+              timespec now = boost::detail::timespec_now();
+              if (boost::detail::timespec_gt(ts, now))
+              {
                 for (int foo=0; foo < 5; ++foo)
                 {
-#   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
-                    timespec ts;
-                    to_timespec_duration(xt, ts);
-                    BOOST_VERIFY(!pthread_delay_np(&ts));
-#   elif defined(BOOST_HAS_NANOSLEEP)
-                    timespec ts;
-                    to_timespec_duration(xt, ts);
-
-                    //  nanosleep takes a timespec that is an offset, not
-                    //  an absolute time.
-                    nanosleep(&ts, 0);
-#   else
-                    mutex mx;
-                    mutex::scoped_lock lock(mx);
-                    condition cond;
-                    cond.timed_wait(lock, xt);
-#   endif
-                    xtime cur;
-                    xtime_get(&cur, TIME_UTC_);
-                    if (xtime_cmp(xt, cur) <= 0)
-                        return;
+
+  #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
+                  timespec d = boost::detail::timespec_minus(ts, now);
+                  BOOST_VERIFY(!pthread_delay_np(&d));
+  #   elif defined(BOOST_HAS_NANOSLEEP)
+                  //  nanosleep takes a timespec that is an offset, not
+                  //  an absolute time.
+                  timespec d = boost::detail::timespec_minus(ts, now);
+                  nanosleep(&d, 0);
+  #   else
+                  mutex mx;
+                  unique_lock<mutex> lock(mx);
+                  condition_variable cond;
+                  cond.do_wait_until(lock, ts);
+  #   endif
+                  timespec now2 = boost::detail::timespec_now();
+                  if (boost::detail::timespec_ge(now2, ts))
+                  {
+                    return;
+                  }
                 }
+              }
             }
         }
-
+      } // hiden
+    } // this_thread
+    namespace this_thread
+    {
         void yield() BOOST_NOEXCEPT
         {
 #   if defined(BOOST_HAS_SCHED_YIELD)
             BOOST_VERIFY(!sched_yield());
 #   elif defined(BOOST_HAS_PTHREAD_YIELD)
             BOOST_VERIFY(!pthread_yield());
+//#   elif defined BOOST_THREAD_USES_DATETIME
+//            xtime xt;
+//            xtime_get(&xt, TIME_UTC_);
+//            sleep(xt);
+//            sleep_for(chrono::milliseconds(0));
 #   else
-            xtime xt;
-            xtime_get(&xt, TIME_UTC_);
-            sleep(xt);
+#error
+            timespec ts;
+            ts.tv_sec= 0;
+            ts.tv_nsec= 0;
+            hiden::sleep_for(ts);
 #   endif
         }
     }
@@ -479,24 +536,7 @@ namespace boost
 #endif
     }
 
-    thread::id thread::get_id() const BOOST_NOEXCEPT
-    {
-    #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
-        //return local_thread_info->thread_handle;
-        return const_cast<thread*>(this)->native_handle();
-    #else
-        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
-        if(local_thread_info)
-        {
-            return id(local_thread_info);
-        }
-        else
-        {
-                return id();
-        }
-    #endif
-    }
-
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
     void thread::interrupt()
     {
         detail::thread_data_ptr const local_thread_info=(get_thread_info)();
@@ -525,6 +565,7 @@ namespace boost
             return false;
         }
     }
+#endif
 
     thread::native_handle_type thread::native_handle()
     {
@@ -542,18 +583,9 @@ namespace boost
 
 
 
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
     namespace this_thread
     {
-        thread::id get_id() BOOST_NOEXCEPT
-        {
-        #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
-             return pthread_self();
-        #else
-            boost::detail::thread_data_base* const thread_info=get_or_make_current_thread_data();
-            return thread::id(thread_info?thread_info->shared_from_this():detail::thread_data_ptr());
-        #endif
-        }
-
         void interruption_point()
         {
 #ifndef BOOST_NO_EXCEPTIONS
@@ -623,6 +655,7 @@ namespace boost
             }
         }
     }
+#endif
 
     namespace detail
     {
@@ -698,6 +731,7 @@ namespace boost
             }
         }
     }
+
     BOOST_THREAD_DECL void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
     {
       detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());