passenger 4.0.20 → 4.0.21

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

@@ -8,7 +8,8 @@
 
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/exceptions.hpp>
-#include <boost/thread/locks.hpp>
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/lock_types.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/pthread/condition_variable_fwd.hpp>
 
@@ -24,6 +25,10 @@
 #include <vector>
 #include <utility>
 
+#if defined(__ANDROID__)
+#include <asm/page.h> // http://code.google.com/p/android/issues/detail?id=39983
+#endif
+
 #include <pthread.h>
 #include <unistd.h>
 
@@ -77,6 +82,7 @@ namespace boost
 
     namespace detail
     {
+        struct future_object_base;
         struct tss_cleanup_function;
         struct thread_exit_callback_node;
         struct tss_data_node
@@ -107,8 +113,7 @@ namespace boost
             bool joined;
             boost::detail::thread_exit_callback_node* thread_exit_callbacks;
             std::map<void const*,boost::detail::tss_data_node> tss_data;
-            bool interrupt_enabled;
-            bool interrupt_requested;
+
             pthread_mutex_t* cond_mutex;
             pthread_cond_t* current_cond;
             typedef std::vector<std::pair<condition_variable*, mutex*>
@@ -116,27 +121,49 @@ namespace boost
             > notify_list_t;
             notify_list_t notify;
 
+            typedef std::vector<shared_ptr<future_object_base> > async_states_t;
+            async_states_t async_states_;
+
+//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            // These data must be at the end so that the access to the other fields doesn't change
+            // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined.
+            // Another option is to have them always
+            bool interrupt_enabled;
+            bool interrupt_requested;
+//#endif
             thread_data_base():
+                thread_handle(0),
                 done(false),join_started(false),joined(false),
                 thread_exit_callbacks(0),
-                interrupt_enabled(true),
-                interrupt_requested(false),
+                cond_mutex(0),
                 current_cond(0),
-                notify()
+                notify(),
+                async_states_()
+//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+                , interrupt_enabled(true)
+                , interrupt_requested(false)
+//#endif
             {}
             virtual ~thread_data_base();
 
             typedef pthread_t native_handle_type;
 
             virtual void run()=0;
-            void notify_all_at_thread_exit(condition_variable* cv, mutex* m)
+            virtual void notify_all_at_thread_exit(condition_variable* cv, mutex* m)
             {
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
+
+            void make_ready_at_thread_exit(shared_ptr<future_object_base> as)
+            {
+              async_states_.push_back(as);
+            }
+
         };
 
         BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
 
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         class interruption_checker
         {
             thread_data_base* const thread_info;
@@ -188,71 +215,47 @@ namespace boost
                 }
             }
         };
+#endif
     }
 
     namespace this_thread
     {
+      namespace hiden
+      {
+        void BOOST_THREAD_DECL sleep_for(const timespec& ts);
+        void BOOST_THREAD_DECL sleep_until(const timespec& ts);
+      }
+
 #ifdef BOOST_THREAD_USES_CHRONO
+#ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY
+
         inline
         void BOOST_SYMBOL_VISIBLE sleep_for(const chrono::nanoseconds& ns)
         {
-            using namespace chrono;
-            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(cv_status::no_timeout==thread_info->sleep_condition.wait_for(lk,ns)) {}
-            }
-            else
-            {
-              if (ns >= nanoseconds::zero())
-              {
-
-  #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
-                timespec ts;
-                ts.tv_sec = static_cast<long>(duration_cast<seconds>(ns).count());
-                ts.tv_nsec = static_cast<long>((ns - seconds(ts.tv_sec)).count());
-                BOOST_VERIFY(!pthread_delay_np(&ts));
-  #   elif defined(BOOST_HAS_NANOSLEEP)
-                timespec ts;
-                ts.tv_sec = static_cast<long>(duration_cast<seconds>(ns).count());
-                ts.tv_nsec = static_cast<long>((ns - seconds(ts.tv_sec)).count());
-                //  nanosleep takes a timespec that is an offset, not
-                //  an absolute time.
-                nanosleep(&ts, 0);
-  #   else
-                mutex mx;
-                mutex::scoped_lock lock(mx);
-                condition_variable cond;
-                cond.wait_for(lock, ns);
-  #   endif
-              }
-            }
+            return boost::this_thread::hiden::sleep_for(boost::detail::to_timespec(ns));
         }
 #endif
+#endif // BOOST_THREAD_USES_CHRONO
+
         void BOOST_THREAD_DECL yield() BOOST_NOEXCEPT;
 
+#if defined BOOST_THREAD_USES_DATETIME
 #ifdef __DECXXX
         /// Workaround of DECCXX issue of incorrect template substitution
-        template<typename TimeDuration>
-        inline void sleep(TimeDuration const& rel_time)
+        template<>
+#endif
+        inline void sleep(system_time const& abs_time)
         {
-            this_thread::sleep(get_system_time()+rel_time);
+          return boost::this_thread::hiden::sleep_until(boost::detail::to_timespec(abs_time));
         }
 
-        template<>
-        void BOOST_THREAD_DECL sleep(system_time const& abs_time);
-#else
-        void BOOST_THREAD_DECL sleep(system_time const& abs_time);
-
         template<typename TimeDuration>
         inline BOOST_SYMBOL_VISIBLE void sleep(TimeDuration const& rel_time)
         {
             this_thread::sleep(get_system_time()+rel_time);
         }
-#endif
-    }
+#endif // BOOST_THREAD_USES_DATETIME
+    } // this_thread
 }
 
 #include <boost/config/abi_suffix.hpp>

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

@@ -1,34 +1,118 @@
 #ifndef BOOST_THREAD_PTHREAD_TIMESPEC_HPP
 #define BOOST_THREAD_PTHREAD_TIMESPEC_HPP
-//  (C) Copyright 2007-8 Anthony Williams 
+//  (C) Copyright 2007-8 Anthony Williams
+//  (C) Copyright 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_time.hpp>
+#if defined BOOST_THREAD_USES_DATETIME
 #include <boost/date_time/posix_time/conversion.hpp>
+#endif
 #include <pthread.h>
 #ifndef _WIN32
 #include <unistd.h>
 #endif
+#ifdef BOOST_THREAD_USES_CHRONO
+#include <boost/chrono/duration.hpp>
+#endif
+
+#if defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+#     define BOOST_THREAD_TIMESPEC_MAC_API
+#include <sys/time.h> //for gettimeofday and timeval
+#else
+#include <time.h>  // for clock_gettime
+#endif
 
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
 {
-    namespace detail
-    {
-        inline struct timespec get_timespec(boost::system_time const& abs_time)
-        {
-            struct timespec timeout={0,0};
-            boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
-            
-            timeout.tv_sec=time_since_epoch.total_seconds();
-            timeout.tv_nsec=(long)(time_since_epoch.fractional_seconds()*(1000000000l/time_since_epoch.ticks_per_second()));
-            return timeout;
-        }
+  namespace detail
+  {
+#if defined BOOST_THREAD_USES_DATETIME
+    inline struct timespec to_timespec(boost::system_time const& abs_time)
+    {
+      struct timespec timeout = { 0,0};
+      boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
+
+      timeout.tv_sec=time_since_epoch.total_seconds();
+      timeout.tv_nsec=(long)(time_since_epoch.fractional_seconds()*(1000000000l/time_since_epoch.ticks_per_second()));
+      return timeout;
+    }
+#endif
+#if defined BOOST_THREAD_USES_CHRONO
+    inline timespec to_timespec(chrono::nanoseconds const& ns)
+    {
+      struct timespec ts;
+      ts.tv_sec = static_cast<long>(chrono::duration_cast<chrono::seconds>(ns).count());
+      ts.tv_nsec = static_cast<long>((ns - chrono::duration_cast<chrono::seconds>(ns)).count());
+      return ts;
     }
+
+#endif
+
+    inline timespec to_timespec(boost::intmax_t const& ns)
+    {
+      boost::intmax_t s = ns / 1000000000l;
+      struct timespec ts;
+      ts.tv_sec = static_cast<long> (s);
+      ts.tv_nsec = static_cast<long> (ns - s * 1000000000l);
+      return ts;
+    }
+    inline boost::intmax_t to_nanoseconds_int_max(timespec const& ts)
+    {
+      return static_cast<boost::intmax_t>(ts.tv_sec) * 1000000000l + ts.tv_nsec;
+    }
+    inline bool timespec_ge_zero(timespec const& ts)
+    {
+      return (ts.tv_sec >= 0) || (ts.tv_nsec >= 0);
+    }
+    inline timespec timespec_now()
+    {
+      timespec ts;
+
+#if defined(BOOST_THREAD_TIMESPEC_MAC_API)
+      timeval tv;
+      ::gettimeofday(&tv, 0);
+      ts.tv_sec = tv.tv_sec;
+      ts.tv_nsec = tv.tv_usec * 1000;
+#else
+      if ( ::clock_gettime( CLOCK_REALTIME, &ts ) )
+      {
+        BOOST_ASSERT(0 && "Boost::Thread - Internal Error");
+      }
+#endif
+      return ts;
+    }
+    inline timespec timespec_zero()
+    {
+      timespec ts;
+      ts.tv_sec = 0;
+      ts.tv_nsec = 0;
+      return ts;
+    }
+    inline timespec timespec_plus(timespec const& lhs, timespec const& rhs)
+    {
+      return to_timespec(to_nanoseconds_int_max(lhs) + to_nanoseconds_int_max(rhs));
+    }
+    inline timespec timespec_minus(timespec const& lhs, timespec const& rhs)
+    {
+      return to_timespec(to_nanoseconds_int_max(lhs) - to_nanoseconds_int_max(rhs));
+    }
+    inline bool timespec_gt(timespec const& lhs, timespec const& rhs)
+    {
+      return to_nanoseconds_int_max(lhs) > to_nanoseconds_int_max(rhs);
+    }
+    inline bool timespec_ge(timespec const& lhs, timespec const& rhs)
+    {
+      return to_nanoseconds_int_max(lhs) >= to_nanoseconds_int_max(rhs);
+    }
+
+  }
 }
 
 #include <boost/config/abi_suffix.hpp>

data/ext/boost/thread/recursive_mutex.hpp

@@ -3,7 +3,7 @@
 
 //  recursive_mutex.hpp
 //
-//  (C) Copyright 2007 Anthony Williams 
+//  (C) Copyright 2007 Anthony Williams
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -18,4 +18,47 @@
 #error "Boost threads unavailable on this platform"
 #endif
 
+#include <boost/thread/lockable_traits.hpp>
+
+namespace boost
+{
+  namespace sync
+  {
+
+#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
+    template<>
+    struct is_basic_lockable<recursive_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_lockable<recursive_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_basic_lockable<recursive_timed_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_lockable<recursive_timed_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+#endif
+
+    template<>
+    struct is_recursive_mutex_sur_parolle<recursive_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_recursive_mutex_sur_parolle<recursive_timed_mutex>
+    {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+
+  }
+}
 #endif

data/ext/boost/thread/reverse_lock.hpp

@@ -6,7 +6,9 @@
 #ifndef BOOST_THREAD_REVERSE_LOCK_HPP
 #define BOOST_THREAD_REVERSE_LOCK_HPP
 #include <boost/thread/detail/config.hpp>
-#include <boost/thread/locks.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/lockable_traits.hpp>
+#include <boost/thread/lock_options.hpp>
 #include <boost/thread/detail/delete.hpp>
 
 namespace boost
@@ -15,7 +17,6 @@ namespace boost
     template<typename Lock>
     class reverse_lock
     {
-
     public:
         typedef typename Lock::mutex_type mutex_type;
         BOOST_THREAD_NO_COPYABLE(reverse_lock)

data/ext/boost/thread/scoped_thread.hpp

@@ -0,0 +1,285 @@
+// 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)
+// (C) Copyright 2009-2012 Anthony Williams
+// (C) Copyright 2012 Vicente J. Botet Escriba
+
+// Based on the Anthony's idea of scoped_thread in CCiA
+
+#ifndef BOOST_THREAD_SCOPED_THREAD_HPP
+#define BOOST_THREAD_SCOPED_THREAD_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/thread_functors.hpp>
+#include <boost/thread/thread_only.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+
+  /**
+   * RAI @c thread wrapper adding a specific destroyer allowing to master what can be done at destruction time.
+   *
+   * CallableThread: A callable void(thread&) .
+   * The default is a join_if_joinable.
+   *
+   * thread std/boost::thread destructor terminates the program if the thread is not joinable.
+   * Having a wrapper that can join the thread before destroying it seems a natural need.
+   *
+   * Example:
+   *
+   *     boost::strict_scoped_thread<> t((boost::thread(F)));
+   *
+   */
+  template <class CallableThread = join_if_joinable>
+  class strict_scoped_thread
+  {
+    thread t_;
+    struct dummy;
+  public:
+
+    BOOST_THREAD_NO_COPYABLE( strict_scoped_thread) /// non copyable
+
+    /*
+     *
+     */
+#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class F, class ...Args>
+    explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args,
+        typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0) :
+      t_(boost::forward<F>(f), boost::forward<Args>(args)...) {}
+#else
+    template <class F>
+    explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f,
+        typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0) :
+      t_(boost::forward<F>(f)) {}
+    template <class F, class A1>
+    strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) :
+      t_(boost::forward<F>(f), boost::forward<A1>(a1)) {}
+    template <class F, class A1, class A2>
+    strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2) :
+      t_(boost::forward<F>(f), boost::forward<A1>(a1), boost::forward<A2>(a2)) {}
+    template <class F, class A1, class A2, class A3>
+    strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2, BOOST_THREAD_FWD_REF(A3) a3) :
+      t_(boost::forward<F>(f), boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)) {}
+#endif
+
+    /**
+     * Constructor from the thread to own.
+     *
+     * @param t: the thread to own.
+     *
+     * Effects: move the thread to own @c t.
+     */
+    explicit strict_scoped_thread(BOOST_THREAD_RV_REF(thread) t) BOOST_NOEXCEPT :
+    t_(boost::move(t))
+    {
+    }
+
+    /**
+     * Destructor
+     * Effects: Call the CallableThread functor before destroying the owned thread.
+     * Remark: The CallableThread should not throw when joining the thread as the scoped variable is on a scope outside the thread function.
+     */
+    ~strict_scoped_thread()
+    {
+      CallableThread on_destructor;
+
+      on_destructor(t_);
+    }
+
+  };
+
+  /**
+   * RAI @c thread wrapper adding a specific destroyer allowing to master what can be done at destruction time.
+   *
+   * CallableThread: A callable void(thread&) .
+   * The default is join_if_joinable.
+   *
+   * thread std::thread destructor terminates the program if the thread is not joinable.
+   * Having a wrapper that can join the thread before destroying it seems a natural need.
+   *
+   * Remark: @c scoped_thread is not a @c thread as @c thread is not designed to be derived from as a polymorphic type.
+   * Anyway @c scoped_thread can be used in most of the contexts a @c thread could be used as it has the
+   * same non-deprecated interface with the exception of the construction.
+   *
+   * Example:
+   *
+   *     boost::scoped_thread<> t((boost::thread(F)));
+   *     t.interrupt();
+   *
+   */
+  template <class CallableThread = join_if_joinable>
+  class scoped_thread
+  {
+    thread t_;
+    struct dummy;
+  public:
+
+    typedef thread::id id;
+
+    BOOST_THREAD_MOVABLE_ONLY( scoped_thread) /// Movable only
+
+    /**
+     * Default Constructor.
+     *
+     * Effects: wraps a not-a-thread.
+     */
+    scoped_thread() BOOST_NOEXCEPT:
+    t_()
+    {
+    }
+
+    /**
+     *
+     */
+
+#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class F, class ...Args>
+    explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args,
+        typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0) :
+      t_(boost::forward<F>(f), boost::forward<Args>(args)...) {}
+#else
+    template <class F>
+    explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f,
+        typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0) :
+      t_(boost::forward<F>(f)) {}
+    template <class F, class A1>
+    scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) :
+      t_(boost::forward<F>(f), boost::forward<A1>(a1)) {}
+    template <class F, class A1, class A2>
+    scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2) :
+      t_(boost::forward<F>(f), boost::forward<A1>(a1), boost::forward<A2>(a2)) {}
+    template <class F, class A1, class A2, class A3>
+    scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2, BOOST_THREAD_FWD_REF(A3) a3) :
+      t_(boost::forward<F>(f), boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)) {}
+
+#endif
+    /**
+     * Constructor from the thread to own.
+     *
+     * @param t: the thread to own.
+     *
+     * Effects: move the thread to own @c t.
+     */
+    explicit scoped_thread(BOOST_THREAD_RV_REF(thread) t) BOOST_NOEXCEPT :
+    t_(boost::move(t))
+    {
+    }
+
+//    explicit operator thread()
+//    {
+//      return boost::move(t_);
+//    }
+
+    /**
+     * Move constructor.
+     */
+    scoped_thread(BOOST_RV_REF(scoped_thread) x) BOOST_NOEXCEPT :
+    t_(boost::move(x.t_))
+    {}
+
+    /**
+     * Destructor
+     *
+     * Effects: Call the CallableThread functor before destroying the owned thread.
+     */
+    ~scoped_thread()
+    {
+      CallableThread on_destructor;
+
+      on_destructor(t_);
+    }
+
+    /**
+     * Move assignment.
+     */
+    scoped_thread& operator=(BOOST_RV_REF(scoped_thread) x)
+    {
+      t_ = boost::move(x.t_);
+      return *this;
+    }
+
+    /**
+     *
+     */
+    void swap(scoped_thread& x) BOOST_NOEXCEPT
+    {
+      t_.swap(x.t_);
+    }
+
+    // forwarded thread functions
+    inline thread::id get_id() const BOOST_NOEXCEPT
+    {
+      return t_.get_id();
+    }
+
+    void detach()
+    {
+      t_.detach();
+    }
+
+    void join()
+    {
+      t_.join();
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    template <class Rep, class Period>
+    bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
+    {
+      return t_.try_join_for(rel_time);
+    }
+
+    template <class Clock, class Duration>
+    bool try_join_until(const chrono::time_point<Clock, Duration>& abs_time)
+    {
+      return t_.try_join_until(abs_time);
+    }
+#endif
+
+    thread::native_handle_type native_handle()BOOST_NOEXCEPT
+    {
+      return t_.native_handle();
+    }
+
+    bool joinable() const BOOST_NOEXCEPT
+    {
+      return t_.joinable();
+    }
+
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+    void interrupt()
+    {
+      t_.interrupt();
+    }
+
+    bool interruption_requested() const BOOST_NOEXCEPT
+    {
+      return t_.interruption_requested();
+    }
+#endif
+
+    static unsigned hardware_concurrency()BOOST_NOEXCEPT
+    {
+      return thread::hardware_concurrency();
+    }
+
+  };
+
+  /**
+   * Effects: swaps the contents of two scoped threads.
+   */
+  template <class Destroyer>
+  void swap(scoped_thread<Destroyer>& lhs, scoped_thread<Destroyer>& rhs)
+BOOST_NOEXCEPT {
+  return lhs.swap(rhs);
+}
+
+}
+#include <boost/config/abi_suffix.hpp>
+
+#endif