passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/thread/detail/thread.hpp

@@ -36,6 +36,7 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/decay.hpp>
 #include <boost/functional/hash.hpp>
+#include <boost/thread/detail/platform_time.hpp>
 #ifdef BOOST_THREAD_USES_CHRONO
 #include <boost/chrono/system_clocks.hpp>
 #include <boost/chrono/ceil.hpp>
@@ -291,7 +292,7 @@ namespace boost
         template <class F>
         explicit thread(F f
         , typename disable_if_c<
-        boost::thread_detail::is_rv<F>::value // todo ass a thread_detail::is_rv
+        boost::thread_detail::is_rv<F>::value // todo as a thread_detail::is_rv
         //boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F)>::value
             //|| is_same<typename decay<F>::type, thread>::value
            , dummy* >::type=0
@@ -454,111 +455,80 @@ namespace boost
         }
 
         class id;
-#ifdef BOOST_THREAD_PLATFORM_PTHREAD
-        inline id get_id()  const BOOST_NOEXCEPT;
-#else
         id get_id() const BOOST_NOEXCEPT;
-#endif
-
 
         bool joinable() const BOOST_NOEXCEPT;
     private:
         bool join_noexcept();
+        bool do_try_join_until_noexcept(detail::internal_platform_timepoint const &timeout, bool& res);
+        bool do_try_join_until(detail::internal_platform_timepoint const &timeout);
     public:
-        inline void join();
+        void join();
 
 #ifdef BOOST_THREAD_USES_CHRONO
-#if defined(BOOST_THREAD_PLATFORM_WIN32)
-        template <class Rep, class Period>
-        bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
-        {
-          chrono::milliseconds rel_time2= chrono::ceil<chrono::milliseconds>(rel_time);
-          return do_try_join_until(rel_time2.count());
-        }
-#else
-        template <class Rep, class Period>
-        bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
+        template <class Duration>
+        bool try_join_until(const chrono::time_point<detail::internal_chrono_clock, Duration>& t)
         {
-          return try_join_until(chrono::steady_clock::now() + rel_time);
+          return do_try_join_until(boost::detail::internal_platform_timepoint(t));
         }
-#endif
-
-#if defined(BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC) && defined(BOOST_THREAD_USEFIXES_TIMESPEC)
-        typedef chrono::steady_clock my_clock_t;
-#else
-        typedef chrono::system_clock my_clock_t;
-#endif
 
         template <class Clock, class Duration>
         bool try_join_until(const chrono::time_point<Clock, Duration>& t)
         {
-          using namespace chrono;
-          bool joined= false;
-          do {
-            my_clock_t::time_point     s_now = my_clock_t::now();
-            typename Clock::duration   d = ceil<nanoseconds>(t-Clock::now());
-            if (d <= Clock::duration::zero()) return false; // in case the Clock::time_point t is already reached
-            joined = try_join_until(s_now + d);
-          } while (! joined);
+          typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
+          common_duration d(t - Clock::now());
+          d = (std::min)(d, common_duration(chrono::milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS)));
+          while ( ! try_join_until(detail::internal_chrono_clock::now() + d) )
+          {
+            d = t - Clock::now();
+            if ( d <= common_duration::zero() ) return false; // timeout occurred
+            d = (std::min)(d, common_duration(chrono::milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS)));
+          }
           return true;
         }
-        template <class Duration>
-        bool try_join_until(const chrono::time_point<my_clock_t, Duration>& t)
-        {
-          using namespace chrono;
-          typedef time_point<my_clock_t, nanoseconds> nano_sys_tmpt;
-          return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
-        }
-#endif
-#if defined(BOOST_THREAD_PLATFORM_WIN32)
-    private:
-        bool do_try_join_until_noexcept(uintmax_t milli, bool& res);
-        inline bool do_try_join_until(uintmax_t milli);
-    public:
-        bool timed_join(const system_time& abs_time);
-        //{
-        //  return do_try_join_until(get_milliseconds_until(wait_until));
-        //}
 
-#ifdef BOOST_THREAD_USES_CHRONO
-        bool try_join_until(const chrono::time_point<my_clock_t, chrono::nanoseconds>& tp)
+        template <class Rep, class Period>
+        bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
         {
-          chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
-          return do_try_join_until(rel_time.count());
+          return try_join_until(chrono::steady_clock::now() + rel_time);
         }
 #endif
-
-
-#else
-    private:
-        bool do_try_join_until_noexcept(struct timespec const &timeout, bool& res);
-        inline bool do_try_join_until(struct timespec const &timeout);
-    public:
 #if defined BOOST_THREAD_USES_DATETIME
         bool timed_join(const system_time& abs_time)
         {
-          struct timespec const ts=detail::to_timespec(abs_time);
+          const detail::real_platform_timepoint ts(abs_time);
+#if defined BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
+          detail::platform_duration d(ts - detail::real_platform_clock::now());
+          d = (std::min)(d, detail::platform_milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS));
+          while ( ! do_try_join_until(detail::internal_platform_clock::now() + d) )
+          {
+            d = ts - detail::real_platform_clock::now();
+            if ( d <= detail::platform_duration::zero() ) return false; // timeout occurred
+            d = (std::min)(d, detail::platform_milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS));
+          }
+          return true;
+#else
           return do_try_join_until(ts);
-        }
 #endif
-#ifdef BOOST_THREAD_USES_CHRONO
-        bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
-        {
-          using namespace chrono;
-          nanoseconds d = tp.time_since_epoch();
-          timespec ts = boost::detail::to_timespec(d);
-          return do_try_join_until(ts);
         }
-#endif
 
-#endif
-      public:
-
-#if defined BOOST_THREAD_USES_DATETIME
         template<typename TimeDuration>
-        inline bool timed_join(TimeDuration const& rel_time)
+        bool timed_join(TimeDuration const& rel_time)
         {
-            return timed_join(get_system_time()+rel_time);
+          detail::platform_duration d(rel_time);
+#if defined(BOOST_THREAD_HAS_MONO_CLOCK) && !defined(BOOST_THREAD_INTERNAL_CLOCK_IS_MONO)
+          const detail::mono_platform_timepoint ts(detail::mono_platform_clock::now() + d);
+          d = (std::min)(d, detail::platform_milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS));
+          while ( ! do_try_join_until(detail::internal_platform_clock::now() + d) )
+          {
+            d = ts - detail::mono_platform_clock::now();
+            if ( d <= detail::platform_duration::zero() ) return false; // timeout occurred
+            d = (std::min)(d, detail::platform_milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS));
+          }
+          return true;
+#else
+          return do_try_join_until(detail::internal_platform_clock::now() + d);
+#endif
         }
 #endif
         void detach();
@@ -612,7 +582,7 @@ namespace boost
     namespace this_thread
     {
 #ifdef BOOST_THREAD_PLATFORM_PTHREAD
-        inline thread::id get_id() BOOST_NOEXCEPT;
+        thread::id get_id() BOOST_NOEXCEPT;
 #else
         thread::id BOOST_THREAD_DECL get_id() BOOST_NOEXCEPT;
 #endif
@@ -743,7 +713,7 @@ namespace boost
     };
 
 #ifdef BOOST_THREAD_PLATFORM_PTHREAD
-    thread::id thread::get_id() const BOOST_NOEXCEPT
+    inline thread::id thread::get_id() const BOOST_NOEXCEPT
     {
     #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
         return const_cast<thread*>(this)->native_handle();
@@ -766,7 +736,7 @@ namespace boost
         }
     }
 #endif
-    void thread::join() {
+    inline void thread::join() {
         if (this_thread::get_id() == get_id())
           boost::throw_exception(thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost thread: trying joining itself"));
 
@@ -775,11 +745,7 @@ namespace boost
         );
     }
 
-#ifdef BOOST_THREAD_PLATFORM_PTHREAD
-    bool thread::do_try_join_until(struct timespec const &timeout)
-#else
-    bool thread::do_try_join_until(uintmax_t timeout)
-#endif
+    inline bool thread::do_try_join_until(detail::internal_platform_timepoint const &timeout)
     {
         if (this_thread::get_id() == get_id())
           boost::throw_exception(thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost thread: trying joining itself"));

data/src/cxx_supportlib/vendor-modified/boost/thread/executors/basic_thread_pool.hpp

@@ -86,11 +86,18 @@ namespace executors
         for(;;)
         {
           work task;
-          queue_op_status st = work_queue.wait_pull(task);
-          if (st == queue_op_status::closed) {
+          try
+          {
+            queue_op_status st = work_queue.wait_pull(task);
+            if (st == queue_op_status::closed) {
+              return;
+            }
+            task();
+          }
+          catch (boost::thread_interrupted&)
+          {
             return;
           }
-          task();
         }
       }
       catch (...)
@@ -234,6 +241,7 @@ namespace executors
     {
       for (unsigned i = 0; i < threads.size(); ++i)
       {
+        threads[i].interrupt();
         threads[i].join();
       }
     }

data/src/cxx_supportlib/vendor-modified/boost/thread/executors/detail/priority_executor_base.hpp

@@ -57,10 +57,16 @@ namespace detail
       {
         for(;;)
         {
-          work task;
-          queue_op_status st = _workq.wait_pull(task);
-          if (st == queue_op_status::closed) return;
-          task();
+          try {
+            work task;
+            queue_op_status st = _workq.wait_pull(task);
+            if (st == queue_op_status::closed) return;
+            task();
+          }
+          catch (boost::thread_interrupted&)
+          {
+            return;
+          }
         }
       }
       catch (...)

data/src/cxx_supportlib/vendor-modified/boost/thread/executors/scheduled_thread_pool.hpp

@@ -32,6 +32,7 @@ namespace executors
     ~scheduled_thread_pool()
     {
       this->close();
+      _workers.interrupt_all();
       _workers.join_all();
     }
 

data/src/cxx_supportlib/vendor-modified/boost/thread/executors/scheduler.hpp

@@ -16,6 +16,11 @@
 
 #include <boost/config/abi_prefix.hpp>
 
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4355) // 'this' : used in base member initializer list
+#endif
+
 namespace boost
 {
   namespace executors
@@ -231,6 +236,7 @@ namespace boost
       ~scheduler()
       {
         this->close();
+        thr.interrupt();
         thr.join();
       }
       template <class Ex>
@@ -266,6 +272,10 @@ namespace boost
   using executors::scheduler;
 }
 
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
 #include <boost/config/abi_suffix.hpp>
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/thread/executors/scheduling_adaptor.hpp

@@ -10,27 +10,33 @@
 
 #include <boost/thread/executors/detail/scheduled_executor_base.hpp>
 
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4355) // 'this' : used in base member initializer list
+#endif
+
 namespace boost
 {
 namespace executors
 {
 
   template <typename Executor>
-  class scheduling_adpator : public detail::scheduled_executor_base<>
+  class scheduling_adaptor : public detail::scheduled_executor_base<>
   {
   private:
     Executor& _exec;
     thread _scheduler;
   public:
 
-    scheduling_adpator(Executor& ex)
+    scheduling_adaptor(Executor& ex)
       : super(),
         _exec(ex),
         _scheduler(&super::loop, this) {}
 
-    ~scheduling_adpator()
+    ~scheduling_adaptor()
     {
       this->close();
+      _scheduler.interrupt();
       _scheduler.join();
     }
 
@@ -45,7 +51,12 @@ namespace executors
 
 } //end executors
 
-  using executors::scheduling_adpator;
+  using executors::scheduling_adaptor;
 
 } //end boost
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
 #endif

data/src/cxx_supportlib/vendor-modified/boost/thread/executors/serial_executor.hpp

@@ -20,6 +20,11 @@
 
 #include <boost/config/abi_prefix.hpp>
 
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4355) // 'this' : used in base member initializer list
+#endif
+
 namespace boost
 {
 namespace executors
@@ -211,6 +216,10 @@ namespace executors
 using executors::serial_executor;
 }
 
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
 #include <boost/config/abi_suffix.hpp>
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/thread/future.hpp

@@ -159,7 +159,7 @@ namespace boost
             boost::function<void()> callback;
             // This declaration should be only included conditionally, but is included to maintain the same layout.
             continuations_type continuations;
-            executor_ptr_type ex;
+            executor_ptr_type ex_;
 
             // This declaration should be only included conditionally, but is included to maintain the same layout.
             virtual void launch_continuation()
@@ -173,43 +173,49 @@ namespace boost
                 is_constructed(false),
                 policy_(launch::none),
                 continuations(),
-                ex()
+                ex_()
             {}
 
-            shared_state_base(exceptional_ptr const& ex_):
-                exception(ex_.ptr_),
+            shared_state_base(exceptional_ptr const& ex):
+                exception(ex.ptr_),
                 done(true),
                 is_valid_(true),
                 is_deferred_(false),
                 is_constructed(false),
                 policy_(launch::none),
                 continuations(),
-                ex()
+                ex_()
             {}
 
 
             virtual ~shared_state_base()
             {
             }
+
+            bool is_done()
+            {
+                return done;
+            }
+
             executor_ptr_type get_executor()
             {
-              return ex;
+              return ex_;
             }
 
             void set_executor_policy(executor_ptr_type aex)
             {
               set_executor();
-              ex = aex;
+              ex_ = aex;
             }
             void set_executor_policy(executor_ptr_type aex, boost::lock_guard<boost::mutex>&)
             {
               set_executor();
-              ex = aex;
+              ex_ = aex;
             }
             void set_executor_policy(executor_ptr_type aex, boost::unique_lock<boost::mutex>&)
             {
               set_executor();
-              ex = aex;
+              ex_ = aex;
             }
 
             bool valid(boost::unique_lock<boost::mutex>&) { return is_valid_; }
@@ -262,6 +268,10 @@ namespace boost
                 external_waiters.erase(it);
             }
 
+#if 0
+            // this inline definition results in ODR. See https://github.com/boostorg/thread/issues/193
+            // to avoid it, we define the function on the derived templates using the macro BOOST_THREAD_DO_CONTINUATION
+#define BOOST_THREAD_DO_CONTINUATION
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
             void do_continuation(boost::unique_lock<boost::mutex>& lock)
             {
@@ -279,6 +289,31 @@ namespace boost
             {
             }
 #endif
+
+#else
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
+#define BOOST_THREAD_DO_CONTINUATION \
+            void do_continuation(boost::unique_lock<boost::mutex>& lock) \
+            { \
+                if (! this->continuations.empty()) { \
+                  continuations_type the_continuations = this->continuations; \
+                  this->continuations.clear(); \
+                  relocker rlk(lock); \
+                  for (continuations_type::iterator it = the_continuations.begin(); it != the_continuations.end(); ++it) { \
+                    (*it)->launch_continuation(); \
+                  } \
+                } \
+            }
+#else
+#define BOOST_THREAD_DO_CONTINUATION \
+            void do_continuation(boost::unique_lock<boost::mutex>&) \
+            { \
+            }
+#endif
+
+            virtual void do_continuation(boost::unique_lock<boost::mutex>&) = 0;
+#endif
+
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
             virtual void set_continuation_ptr(continuation_ptr_type continuation, boost::unique_lock<boost::mutex>& lock)
             {
@@ -299,7 +334,7 @@ namespace boost
                 }
                 do_continuation(lock);
             }
-            void make_ready()
+            void notify_deferred()
             {
               boost::unique_lock<boost::mutex> lock(this->mutex);
               mark_finished_internal(lock);
@@ -348,10 +383,7 @@ namespace boost
                 is_deferred_=false;
                 execute(lk);
               }
-              while(!done)
-              {
-                  waiters.wait(lk);
-              }
+              waiters.wait(lk, boost::bind(&shared_state_base::is_done, boost::ref(*this)));
               if(rethrow && exception)
               {
                   boost::rethrow_exception(exception);
@@ -370,6 +402,17 @@ namespace boost
             }
 
 #if defined BOOST_THREAD_USES_DATETIME
+            template<typename Duration>
+            bool timed_wait(Duration const& rel_time)
+            {
+                boost::unique_lock<boost::mutex> lock(this->mutex);
+                if (is_deferred_)
+                    return false;
+
+                do_callback(lock);
+                return waiters.timed_wait(lock, rel_time, boost::bind(&shared_state_base::is_done, boost::ref(*this)));
+            }
+
             bool timed_wait_until(boost::system_time const& target_time)
             {
                 boost::unique_lock<boost::mutex> lock(this->mutex);
@@ -377,15 +420,7 @@ namespace boost
                     return false;
 
                 do_callback(lock);
-                while(!done)
-                {
-                    bool const success=waiters.timed_wait(lock,target_time);
-                    if(!success && !done)
-                    {
-                        return false;
-                    }
-                }
-                return true;
+                return waiters.timed_wait(lock, target_time, boost::bind(&shared_state_base::is_done, boost::ref(*this)));
             }
 #endif
 #ifdef BOOST_THREAD_USES_CHRONO
@@ -398,13 +433,9 @@ namespace boost
               if (is_deferred_)
                   return future_status::deferred;
               do_callback(lock);
-              while(!done)
+              if(!waiters.wait_until(lock, abs_time, boost::bind(&shared_state_base::is_done, boost::ref(*this))))
               {
-                  cv_status const st=waiters.wait_until(lock,abs_time);
-                  if(st==cv_status::timeout && !done)
-                  {
-                    return future_status::timeout;
-                  }
+                  return future_status::timeout;
               }
               return future_status::ready;
             }
@@ -421,7 +452,7 @@ namespace boost
                 mark_exceptional_finish_internal(boost::current_exception(), lock);
             }
 
-            void set_exception_at_thread_exit(exception_ptr e)
+            void set_exception_deferred(exception_ptr e)
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (has_value(lk))
@@ -430,6 +461,17 @@ namespace boost
               }
               exception=e;
               this->is_constructed = true;
+            }
+            void set_exception_at_thread_exit(exception_ptr e)
+            {
+              set_exception_deferred(e);
+//              unique_lock<boost::mutex> lk(this->mutex);
+//              if (has_value(lk))
+//              {
+//                  throw_exception(promise_already_satisfied());
+//              }
+//              exception=e;
+//              this->is_constructed = true;
               detail::make_ready_at_thread_exit(shared_from_this());
             }
 
@@ -535,10 +577,8 @@ namespace boost
               detail::shared_state_base(ex), result()
             {}
 
-
-            ~shared_state()
-            {
-            }
+            // locating this definition on the template avoid the ODR issue. See https://github.com/boostorg/thread/issues/193
+            BOOST_THREAD_DO_CONTINUATION
 
             void mark_finished_with_result_internal(source_reference_type result_, boost::unique_lock<boost::mutex>& lock)
             {
@@ -617,8 +657,7 @@ namespace boost
                 boost::unique_lock<boost::mutex> lk(this->mutex);
                 return this->get_sh(lk);
             }
-
-            void set_value_at_thread_exit(source_reference_type result_)
+            void set_value_deferred(source_reference_type result_)
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (this->has_value(lk))
@@ -632,13 +671,14 @@ namespace boost
 #endif
 
               this->is_constructed = true;
-              detail::make_ready_at_thread_exit(shared_from_this());
             }
-            void set_value_at_thread_exit(rvalue_source_type result_)
+            void set_value_deferred(rvalue_source_type result_)
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (this->has_value(lk))
+              {
                   throw_exception(promise_already_satisfied());
+              }
 
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL
@@ -654,6 +694,46 @@ namespace boost
 #endif
 #endif
               this->is_constructed = true;
+            }
+
+            void set_value_at_thread_exit(source_reference_type result_)
+            {
+                set_value_deferred(result_);
+//              unique_lock<boost::mutex> lk(this->mutex);
+//              if (this->has_value(lk))
+//              {
+//                  throw_exception(promise_already_satisfied());
+//              }
+//#if defined BOOST_THREAD_FUTURE_USES_OPTIONAL
+//              result = result_;
+//#else
+//              result.reset(new T(result_));
+//#endif
+//
+//              this->is_constructed = true;
+              detail::make_ready_at_thread_exit(shared_from_this());
+            }
+            void set_value_at_thread_exit(rvalue_source_type result_)
+            {
+                set_value_deferred(boost::move(result_));
+//              unique_lock<boost::mutex> lk(this->mutex);
+//              if (this->has_value(lk))
+//                  throw_exception(promise_already_satisfied());
+//
+//#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
+//#if defined BOOST_THREAD_FUTURE_USES_OPTIONAL
+//                result = boost::move(result_);
+//#else
+//                result.reset(new T(boost::move(result_)));
+//#endif
+//#else
+//#if defined BOOST_THREAD_FUTURE_USES_OPTIONAL
+//                result = boost::move(result_);
+//#else
+//                result.reset(new T(static_cast<rvalue_source_type>(result_)));
+//#endif
+//#endif
+//              this->is_constructed = true;
               detail::make_ready_at_thread_exit(shared_from_this());
             }
 
@@ -681,9 +761,8 @@ namespace boost
               detail::shared_state_base(ex), result(0)
             {}
 
-            ~shared_state()
-            {
-            }
+            // locating this definition on the template avoid the ODR issue. See https://github.com/boostorg/thread/issues/193
+            BOOST_THREAD_DO_CONTINUATION
 
             void mark_finished_with_result_internal(source_reference_type result_, boost::unique_lock<boost::mutex>& lock)
             {
@@ -719,13 +798,25 @@ namespace boost
                 return get_sh(lock);
             }
 
-            void set_value_at_thread_exit(T& result_)
+            void set_value_deferred(T& result_)
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (this->has_value(lk))
+              {
                   throw_exception(promise_already_satisfied());
+              }
               result= &result_;
               this->is_constructed = true;
+            }
+
+            void set_value_at_thread_exit(T& result_)
+            {
+              set_value_deferred(result_);
+//              unique_lock<boost::mutex> lk(this->mutex);
+//              if (this->has_value(lk))
+//                  throw_exception(promise_already_satisfied());
+//              result= &result_;
+//              this->is_constructed = true;
               detail::make_ready_at_thread_exit(shared_from_this());
             }
 
@@ -748,6 +839,9 @@ namespace boost
               detail::shared_state_base(ex)
             {}
 
+            // locating this definition on the template avoid the ODR issue. See https://github.com/boostorg/thread/issues/193
+            BOOST_THREAD_DO_CONTINUATION
+
             void mark_finished_with_result_internal(boost::unique_lock<boost::mutex>& lock)
             {
                 mark_finished_internal(lock);
@@ -779,7 +873,7 @@ namespace boost
                 this->get_sh(lock);
             }
 
-            void set_value_at_thread_exit()
+            void set_value_deferred()
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (this->has_value(lk))
@@ -787,6 +881,16 @@ namespace boost
                   throw_exception(promise_already_satisfied());
               }
               this->is_constructed = true;
+            }
+            void set_value_at_thread_exit()
+            {
+              set_value_deferred();
+//              unique_lock<boost::mutex> lk(this->mutex);
+//              if (this->has_value(lk))
+//              {
+//                  throw_exception(promise_already_satisfied());
+//              }
+//              this->is_constructed = true;
               detail::make_ready_at_thread_exit(shared_from_this());
             }
         private:
@@ -826,10 +930,7 @@ namespace boost
             join();
 #elif defined BOOST_THREAD_ASYNC_FUTURE_WAITS
             unique_lock<boost::mutex> lk(this->mutex);
-            while(!this->done)
-            {
-              this->waiters.wait(lk);
-            }
+            this->waiters.wait(lk, boost::bind(&shared_state_base::is_done, boost::ref(*this)));
 #endif
           }
 
@@ -934,10 +1035,8 @@ namespace boost
         template<typename Rp, typename Fp>
         struct future_deferred_shared_state: shared_state<Rp>
         {
-          typedef shared_state<Rp> base_type;
           Fp func_;
 
-        public:
           explicit future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f)
           : func_(boost::move(f))
           {
@@ -962,10 +1061,8 @@ namespace boost
         template<typename Rp, typename Fp>
         struct future_deferred_shared_state<Rp&,Fp>: shared_state<Rp&>
         {
-          typedef shared_state<Rp&> base_type;
           Fp func_;
 
-        public:
           explicit future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f)
           : func_(boost::move(f))
           {
@@ -987,10 +1084,8 @@ namespace boost
         template<typename Fp>
         struct future_deferred_shared_state<void,Fp>: shared_state<void>
         {
-          typedef shared_state<void> base_type;
           Fp func_;
 
-        public:
           explicit future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f)
           : func_(boost::move(f))
           {
@@ -1018,7 +1113,6 @@ namespace boost
         public:
             typedef std::vector<int>::size_type count_type;
         private:
-            struct registered_waiter;
             struct registered_waiter
             {
                 boost::shared_ptr<detail::shared_state_base> future_;
@@ -1335,7 +1429,7 @@ namespace boost
 
         bool valid() const BOOST_NOEXCEPT
         {
-            return future_ != 0 && future_->valid();
+            return future_.get() != 0 && future_->valid();
         }
 
         void wait() const
@@ -1379,7 +1473,11 @@ namespace boost
         template<typename Duration>
         bool timed_wait(Duration const& rel_time) const
         {
-            return timed_wait_until(boost::get_system_time()+rel_time);
+            if(!future_)
+            {
+                boost::throw_exception(future_uninitialized());
+            }
+            return future_->timed_wait(rel_time);
         }
 
         bool timed_wait_until(boost::system_time const& abs_time) const
@@ -1639,7 +1737,9 @@ namespace boost
         base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other))))
         {
         }
+#if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP
         inline explicit BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R> >) other); // EXTENSION
+#endif
 
         explicit BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(shared_future<R>) other) :
         base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other))))
@@ -1680,7 +1780,7 @@ namespace boost
         // retrieving the value
         move_dest_type get()
         {
-            if (this->future_ == 0)
+            if (this->future_.get() == 0)
             {
                 boost::throw_exception(future_uninitialized());
             }
@@ -1700,7 +1800,7 @@ namespace boost
         get_or(BOOST_THREAD_RV_REF(R2) v)
         {
 
-            if (this->future_ == 0)
+            if (this->future_.get() == 0)
             {
                 boost::throw_exception(future_uninitialized());
             }
@@ -1726,7 +1826,7 @@ namespace boost
         typename boost::disable_if< is_void<R2>, move_dest_type>::type
         get_or(R2 const& v)  // EXTENSION
         {
-            if (this->future_ == 0)
+            if (this->future_.get() == 0)
             {
                 boost::throw_exception(future_uninitialized());
             }
@@ -1941,7 +2041,7 @@ namespace boost
             // retrieving the value
             move_dest_type get()
             {
-                if (this->future_ == 0)
+                if (this->future_.get() == 0)
                 {
                     boost::throw_exception(future_uninitialized());
                 }
@@ -1957,7 +2057,7 @@ namespace boost
             }
             move_dest_type get_or(BOOST_THREAD_RV_REF(R) v) // EXTENSION
             {
-                if (this->future_ == 0)
+                if (this->future_.get() == 0)
                 {
                     boost::throw_exception(future_uninitialized());
                 }
@@ -1976,7 +2076,7 @@ namespace boost
 
             move_dest_type get_or(R const& v) // EXTENSION
             {
-                if (this->future_ == 0)
+                if (this->future_.get() == 0)
                 {
                     boost::throw_exception(future_uninitialized());
                 }
@@ -2163,13 +2263,13 @@ namespace boost
         void lazy_init()
         {
 #if defined BOOST_THREAD_PROVIDES_PROMISE_LAZY
-#include <boost/detail/atomic_undef_macros.hpp>
+#include <boost/thread/detail/atomic_undef_macros.hpp>
           if(!atomic_load(&future_))
             {
                 future_ptr blank;
                 atomic_compare_exchange(&future_,&blank,future_ptr(new detail::shared_state<R>));
             }
-#include <boost/detail/atomic_redef_macros.hpp>
+#include <boost/thread/detail/atomic_redef_macros.hpp>
 #endif
         }
 
@@ -2261,7 +2361,8 @@ namespace boost
 
 #if defined  BOOST_NO_CXX11_RVALUE_REFERENCES
         template <class TR>
-        typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type set_value(TR const &  r)
+        typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type
+            set_value(TR const &  r)
         {
             lazy_init();
             boost::unique_lock<boost::mutex> lock(future_->mutex);
@@ -2299,6 +2400,44 @@ namespace boost
 #endif
         }
 
+#if defined  BOOST_NO_CXX11_RVALUE_REFERENCES
+        template <class TR>
+        typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type
+            set_value_deferred(TR const &  r)
+        {
+            lazy_init();
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->set_value_deferred(r);
+        }
+#else
+        void set_value_deferred(source_reference_type r)
+        {
+            lazy_init();
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->set_value_deferred(r);
+        }
+#endif
+
+        void set_value_deferred(rvalue_source_type r)
+        {
+            lazy_init();
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
+            future_->set_value_deferred(boost::move(r));
+#else
+            future_->set_value_deferred(static_cast<rvalue_source_type>(r));
+#endif
+        }
+
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
         template <class ...Args>
         void emplace(BOOST_THREAD_FWD_REF(Args) ...args)
@@ -2329,6 +2468,21 @@ namespace boost
         {
           set_exception(boost::copy_exception(ex));
         }
+        void set_exception_deferred(boost::exception_ptr p)
+        {
+            lazy_init();
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->set_exception_deferred(p);
+        }
+        template <typename E>
+        void set_exception_deferred(E ex)
+        {
+          set_exception_deferred(boost::copy_exception(ex));
+        }
+
         // setting the result with deferred notification
 #if defined  BOOST_NO_CXX11_RVALUE_REFERENCES
         template <class TR>
@@ -2378,6 +2532,14 @@ namespace boost
             lazy_init();
             future_->set_wait_callback(f,this);
         }
+        void notify_deferred()
+        {
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->notify_deferred();
+        }
 
     };
 
@@ -2392,13 +2554,13 @@ namespace boost
         void lazy_init()
         {
 #if defined BOOST_THREAD_PROVIDES_PROMISE_LAZY
-#include <boost/detail/atomic_undef_macros.hpp>
+#include <boost/thread/detail/atomic_undef_macros.hpp>
             if(!atomic_load(&future_))
             {
                 future_ptr blank;
                 atomic_compare_exchange(&future_,&blank,future_ptr(new detail::shared_state<R&>));
             }
-#include <boost/detail/atomic_redef_macros.hpp>
+#include <boost/thread/detail/atomic_redef_macros.hpp>
 #endif
         }
 
@@ -2486,7 +2648,15 @@ namespace boost
             }
             future_->mark_finished_with_result_internal(r, lock);
         }
-
+        void set_value_deferred(R& r)
+        {
+            lazy_init();
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_already_satisfied());
+            }
+            future_->set_value_deferred(r);
+        }
         void set_exception(boost::exception_ptr p)
         {
             lazy_init();
@@ -2502,7 +2672,20 @@ namespace boost
         {
           set_exception(boost::copy_exception(ex));
         }
-
+        void set_exception_deferred(boost::exception_ptr p)
+        {
+            lazy_init();
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->set_exception_deferred(p);
+        }
+        template <typename E>
+        void set_exception_deferred(E ex)
+        {
+          set_exception_deferred(boost::copy_exception(ex));
+        }
         // setting the result with deferred notification
         void set_value_at_thread_exit(R& r)
         {
@@ -2533,6 +2716,14 @@ namespace boost
             lazy_init();
             future_->set_wait_callback(f,this);
         }
+        void notify_deferred()
+        {
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->notify_deferred();
+        }
     };
 
     template <>
@@ -2642,6 +2833,15 @@ namespace boost
             }
             future_->mark_finished_with_result_internal(lock);
         }
+        void set_value_deferred()
+        {
+            lazy_init();
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->set_value_deferred();
+        }
 
         void set_exception(boost::exception_ptr p)
         {
@@ -2658,7 +2858,20 @@ namespace boost
         {
           set_exception(boost::copy_exception(ex));
         }
-
+        void set_exception_deferred(boost::exception_ptr p)
+        {
+            lazy_init();
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->set_exception_deferred(p);
+        }
+        template <typename E>
+        void set_exception_deferred(E ex)
+        {
+          set_exception_deferred(boost::copy_exception(ex));
+        }
         // setting the result with deferred notification
         void set_value_at_thread_exit()
         {
@@ -2689,7 +2902,14 @@ namespace boost
             lazy_init();
             future_->set_wait_callback(f,this);
         }
-
+        void notify_deferred()
+        {
+            if (future_.get()==0)
+            {
+                boost::throw_exception(promise_moved());
+            }
+            future_->notify_deferred();
+        }
     };
 }
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
@@ -2960,7 +3180,7 @@ namespace boost
             }
         };
 
-#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
 
 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK
 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
@@ -3302,7 +3522,7 @@ namespace boost
         {}
 
         // construction and destruction
-#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
 
 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK
   #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
@@ -3392,7 +3612,7 @@ namespace boost
 #endif
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
-#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
         template <class Allocator>
         packaged_task(boost::allocator_arg_t, Allocator a, R(*f)())
         {
@@ -3413,7 +3633,7 @@ namespace boost
           task = task_ptr(::new(a2.allocate(1)) task_shared_state_type(f), D(a2, 1) );
           future_obtained = false;
         }
-#endif // BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#endif // BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
 #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
         template <class F, class Allocator>
@@ -3630,7 +3850,7 @@ namespace detail
     // future<R> async(launch policy, F&&, ArgTypes&&...);
     ////////////////////////////////
 
-#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
   template <class R, class... ArgTypes>
@@ -3689,7 +3909,7 @@ namespace detail
     }
   }
 #endif
-#endif // defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#endif // defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
 
 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 
@@ -3918,7 +4138,7 @@ namespace detail {
 //#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #if defined(BOOST_THREAD_PROVIDES_INVOKE) && ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ! defined(BOOST_NO_CXX11_HDR_TUPLE)
 
-#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
   template <class Executor, class R, class... ArgTypes>
   BOOST_THREAD_FUTURE<R>
@@ -3934,7 +4154,7 @@ namespace detail {
         )
     ));
   }
-#endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
   template <class Executor, class F, class ...ArgTypes>
   BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type(
@@ -3953,7 +4173,7 @@ namespace detail {
   }
 
 #else // ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
   template <class Executor, class R>
   BOOST_THREAD_FUTURE<R>
@@ -3983,7 +4203,7 @@ namespace detail {
         )
     ));
   }
-#endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
   template <class Executor, class F>
   BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type()>::type>
@@ -4039,7 +4259,7 @@ namespace detail {
   // future<R> async(F&&, ArgTypes&&...);
   ////////////////////////////////
 
-#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
   #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
   template <class R, class... ArgTypes>
   BOOST_THREAD_FUTURE<R>
@@ -4747,7 +4967,7 @@ namespace detail {
   inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type>
   BOOST_THREAD_FUTURE<R>::then(launch policy, BOOST_THREAD_FWD_REF(F) func) {
     typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     // keep state alive as we move ourself but hold the lock
     shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4761,6 +4981,10 @@ namespace detail {
       return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_deferred_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>(
                   lock, boost::move(*this), boost::forward<F>(func)
               )));
+    } else if (underlying_cast<int>(policy) & int(launch::sync)) {
+      return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_sync_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>(
+                  lock, boost::move(*this), boost::forward<F>(func)
+              )));
 #ifdef BOOST_THREAD_PROVIDES_EXECUTORS
     } else if (underlying_cast<int>(policy) & int(launch::executor)) {
       assert(this->future_->get_executor());
@@ -4781,6 +5005,10 @@ namespace detail {
           return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_deferred_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>(
                       lock, boost::move(*this), boost::forward<F>(func)
                   )));
+        } else if (underlying_cast<int>(policy_) & int(launch::sync)) {
+          return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_sync_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>(
+                      lock, boost::move(*this), boost::forward<F>(func)
+                  )));
 #ifdef BOOST_THREAD_PROVIDES_EXECUTORS
         } else if (underlying_cast<int>(policy_) & int(launch::executor)) {
           assert(this->future_->get_executor());
@@ -4811,7 +5039,7 @@ namespace detail {
   inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type>
   BOOST_THREAD_FUTURE<R>::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func) {
     typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     // keep state alive as we move ourself but hold the lock
     shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4835,7 +5063,7 @@ namespace detail {
     return this->then(this->launch_policy(), boost::forward<F>(func));
 #else
     typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     // keep state alive as we move ourself but hold the lock
     shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4865,7 +5093,7 @@ namespace detail {
   BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::then(launch policy, BOOST_THREAD_FWD_REF(F) func) {
     typedef BOOST_THREAD_FUTURE<R2> R;
     typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     // keep state alive as we move ourself but hold the lock
     shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4939,7 +5167,7 @@ namespace detail {
   BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func) {
     typedef BOOST_THREAD_FUTURE<R2> R;
     typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     // keep state alive as we move ourself but hold the lock
     shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4965,7 +5193,7 @@ namespace detail {
 #else
     typedef BOOST_THREAD_FUTURE<R2> R;
     typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     // keep state alive as we move ourself but hold the lock
     shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4995,7 +5223,7 @@ namespace detail {
   shared_future<R>::then(launch policy, BOOST_THREAD_FWD_REF(F) func)  const
   {
     typedef typename boost::result_of<F(shared_future<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     boost::unique_lock<boost::mutex> lock(this->future_->mutex);
     if (underlying_cast<int>(policy) & int(launch::async)) {
@@ -5064,7 +5292,7 @@ namespace detail {
   shared_future<R>::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func)  const
   {
     typedef typename boost::result_of<F(shared_future<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     boost::unique_lock<boost::mutex> lock(this->future_->mutex);
     return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_executor_continuation_shared_state<Ex, shared_future<R>, future_type>(ex,
@@ -5085,7 +5313,7 @@ namespace detail {
     return this->then(this->launch_policy(), boost::forward<F>(func));
 #else
     typedef typename boost::result_of<F(shared_future<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     boost::unique_lock<boost::mutex> lock(this->future_->mutex);
     launch policy = this->launch_policy(lock);
@@ -5257,7 +5485,7 @@ namespace detail
   BOOST_THREAD_FUTURE<R2>
   BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::unwrap()
   {
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
 
     // keep state alive as we move ourself but hold the lock
     shared_ptr<detail::shared_state_base> sentinel(this->future_);