passenger 4.0.20 → 4.0.21

data/ext/boost/thread/poly_shared_lockable.hpp

@@ -0,0 +1,135 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009,2012. 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)
+//
+// See http://www.boost.org/libs/thread for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_THREAD_POLY_SHARED_LOCKABLE_HPP
+#define BOOST_THREAD_POLY_SHARED_LOCKABLE_HPP
+
+#include <boost/thread/poly_lockable.hpp>
+#include <boost/chrono/chrono.hpp>
+
+namespace boost
+{
+
+
+  //[shared_poly_lockable
+  class shared_poly_lockable: public timed_poly_lockable
+  {
+  public:
+    virtual ~shared_poly_lockable() = 0;
+
+    virtual void lock_shared() = 0;
+    virtual bool try_lock_shared() = 0;
+    virtual void unlock_shared() = 0;
+
+    virtual bool try_lock_shared_until(chrono::system_clock::time_point const & abs_time)=0;
+    virtual bool try_lock_shared_until(chrono::steady_clock::time_point const & abs_time)=0;
+    template <typename Clock, typename Duration>
+    bool try_lock_shared_until(chrono::time_point<Clock, Duration> const & abs_time)
+    {
+      return try_lock_shared_until(time_point_cast<Clock::time_point>(abs_time));
+    }
+
+    virtual bool try_lock_shared_for(chrono::nanoseconds const & relative_time)=0;
+    template <typename Rep, typename Period>
+    bool try_lock_shared_for(chrono::duration<Rep, Period> const & rel_time)
+    {
+      return try_lock_shared_for(duration_cast<Clock::duration>(rel_time));
+    }
+
+  };
+
+  //]
+
+  //[upgrade_poly_lockable
+  class upgrade_poly_lockable: public shared_poly_lockable
+  {
+  public:
+    virtual ~upgrade_poly_lockable() = 0;
+
+    virtual void lock_upgrade() = 0;
+    virtual bool try_lock_upgrade() = 0;
+    virtual void unlock_upgrade() = 0;
+
+    virtual bool try_lock_upgrade_until(chrono::system_clock::time_point const & abs_time)=0;
+    virtual bool try_lock_upgrade_until(chrono::steady_clock::time_point const & abs_time)=0;
+    template <typename Clock, typename Duration>
+    bool try_lock_upgrade_until(chrono::time_point<Clock, Duration> const & abs_time)
+    {
+      return try_lock_upgrade_until(time_point_cast<Clock::time_point>(abs_time));
+    }
+
+    virtual bool try_lock_upgrade_for(chrono::nanoseconds const & relative_time)=0;
+    template <typename Rep, typename Period>
+    bool try_lock_upgrade_for(chrono::duration<Rep, Period> const & rel_time)
+    {
+      return try_lock_upgrade_for(duration_cast<Clock::duration>(rel_time));
+    }
+
+    virtual bool try_unlock_shared_and_lock() = 0;
+
+    virtual bool try_unlock_shared_and_lock_until(chrono::system_clock::time_point const & abs_time)=0;
+    virtual bool try_unlock_shared_and_lock_until(chrono::steady_clock::time_point const & abs_time)=0;
+    template <typename Clock, typename Duration>
+    bool try_unlock_shared_and_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
+    {
+      return try_unlock_shared_and_lock_until(time_point_cast<Clock::time_point>(abs_time));
+    }
+
+    virtual bool try_unlock_shared_and_lock_for(chrono::nanoseconds const & relative_time)=0;
+    template <typename Rep, typename Period>
+    bool try_unlock_shared_and_lock_for(chrono::duration<Rep, Period> const & rel_time)
+    {
+      return try_unlock_shared_and_lock_for(duration_cast<Clock::duration>(rel_time));
+    }
+
+    virtual void unlock_and_lock_shared() = 0;
+    virtual bool try_unlock_shared_and_lock_upgrade() = 0;
+
+    virtual bool try_unlock_shared_and_lock_upgrade_until(chrono::system_clock::time_point const & abs_time)=0;
+    virtual bool try_unlock_shared_and_lock_upgrade_until(chrono::steady_clock::time_point const & abs_time)=0;
+    template <typename Clock, typename Duration>
+    bool try_unlock_shared_and_lock_upgrade_until(chrono::time_point<Clock, Duration> const & abs_time)
+    {
+      return try_unlock_shared_and_lock_upgrade_until(time_point_cast<Clock::time_point>(abs_time));
+    }
+
+    virtual bool try_unlock_shared_and_lock_upgrade_for(chrono::nanoseconds const & relative_time)=0;
+    template <typename Rep, typename Period>
+    bool try_unlock_shared_and_lock_upgrade_for(chrono::duration<Rep, Period> const & rel_time)
+    {
+      return try_unlock_shared_and_lock_upgrade_for(duration_cast<Clock::duration>(rel_time));
+    }
+
+    virtual void unlock_and_lock_upgrade() = 0;
+    virtual void unlock_upgrade_and_lock() = 0;
+    virtual bool try_unlock_upgrade_and_lock() = 0;
+
+    virtual bool try_unlock_upgrade_and_lock_until(chrono::system_clock::time_point const & abs_time)=0;
+    virtual bool try_unlock_upgrade_and_lock_until(chrono::steady_clock::time_point const & abs_time)=0;
+    template <typename Clock, typename Duration>
+    bool try_unlock_upgrade_and_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
+    {
+      return try_unlock_upgrade_and_lock_until(time_point_cast<Clock::time_point>(abs_time));
+    }
+
+    virtual bool try_unlock_upgrade_and_lock_for(chrono::nanoseconds const & relative_time)=0;
+    template <typename Rep, typename Period>
+    bool try_unlock_upgrade_and_lock_for(chrono::duration<Rep, Period> const & rel_time)
+    {
+      return try_unlock_upgrade_and_lock_for(duration_cast<Clock::duration>(rel_time));
+    }
+
+    virtual void unlock_upgrade_and_lock_shared() = 0;
+
+  };
+//]
+
+}
+#endif

data/ext/boost/thread/poly_shared_lockable_adapter.hpp

@@ -0,0 +1,170 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009,2012. 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)
+//
+// See http://www.boost.org/libs/thread for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_THREAD_POLY_SHARED_LOCKABLE_ADAPTER_HPP
+#define BOOST_THREAD_POLY_SHARED_LOCKABLE_ADAPTER_HPP
+
+#include <boost/thread/poly_lockable_adapter.hpp>
+#include <boost/thread/poly_shared_lockable.hpp>
+
+namespace boost
+{
+
+  //[shared_lockable_adapter
+  template <typename Mutex, typename Base=poly_shared_lockable>
+  class poly_shared_lockable_adapter: public poly_timed_lockable_adapter<Mutex, Base>
+  {
+  public:
+    typedef Mutex mutex_type;
+
+    void lock_shared()
+    {
+      this->mtx().lock_shared();
+    }
+    bool try_lock_shared()
+    {
+      return this->mtx().try_lock_shared();
+    }
+    void unlock_shared()
+    {
+      this->mtx().unlock_shared();
+    }
+
+    bool try_lock_shared_until(chrono::system_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_lock_shared_until(abs_time);
+    }
+    bool try_lock_shared_until(chrono::steady_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_lock_shared_until(abs_time);
+    }
+    bool try_lock_shared_for(chrono::nanoseconds const & rel_time)
+    {
+      return this->mtx().try_lock_shared_for(rel_time);
+    }
+
+  };
+
+  //]
+
+  //[upgrade_lockable_adapter
+  template <typename Mutex, typename Base=poly_shared_lockable>
+  class upgrade_lockable_adapter: public shared_lockable_adapter<Mutex, Base>
+  {
+  public:
+    typedef Mutex mutex_type;
+
+    void lock_upgrade()
+    {
+      this->mtx().lock_upgrade();
+    }
+
+    bool try_lock_upgrade()
+    {
+      return this->mtx().try_lock_upgrade();
+    }
+
+    void unlock_upgrade()
+    {
+      this->mtx().unlock_upgrade();
+    }
+
+    bool try_lock_upgrade_until(chrono::system_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_lock_upgrade_until(abs_time);
+    }
+    bool try_lock_upgrade_until(chrono::steady_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_lock_upgrade_until(abs_time);
+    }
+    bool try_lock_upgrade_for(chrono::nanoseconds const & rel_time)
+    {
+      return this->mtx().try_lock_upgrade_for(rel_time);
+    }
+
+    bool try_unlock_shared_and_lock()
+    {
+      return this->mtx().try_unlock_shared_and_lock();
+    }
+
+    bool try_unlock_shared_and_lock_until(chrono::system_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_unlock_shared_and_lock_until(abs_time);
+    }
+    bool try_unlock_shared_and_lock_until(chrono::steady_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_unlock_shared_and_lock_until(abs_time);
+    }
+    template <typename Rep, typename Period>
+    bool try_unlock_shared_and_lock_for(chrono::nanoseconds const & rel_time)
+    {
+      return this->mtx().try_unlock_shared_and_lock_for(rel_time);
+    }
+
+    void unlock_and_lock_shared()
+    {
+      this->mtx().unlock_and_lock_shared();
+    }
+
+    bool try_unlock_shared_and_lock_upgrade()
+    {
+      return this->mtx().try_unlock_shared_and_lock_upgrade();
+    }
+
+    bool try_unlock_shared_and_lock_upgrade_until(chrono::system_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_unlock_shared_and_lock_upgrade_until(abs_time);
+    }
+    bool try_unlock_shared_and_lock_upgrade_until(chrono::steady_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_unlock_shared_and_lock_upgrade_until(abs_time);
+    }
+    bool try_unlock_shared_and_lock_upgrade_for(chrono::nanoseconds const & rel_time)
+    {
+      return this->mtx().try_unlock_shared_and_lock_upgrade_for(rel_time);
+    }
+
+    void unlock_and_lock_upgrade()
+    {
+      this->mtx().unlock_and_lock_upgrade();
+    }
+
+    void unlock_upgrade_and_lock()
+    {
+      this->mtx().unlock_upgrade_and_lock();
+    }
+
+    bool try_unlock_upgrade_and_lock()
+    {
+      return this->mtx().try_unlock_upgrade_and_lock();
+    }
+    bool try_unlock_upgrade_and_lock_until(chrono::system_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_unlock_upgrade_and_lock_until(abs_time);
+    }
+    bool try_unlock_upgrade_and_lock_until(chrono::steady_clock::time_point const & abs_time)
+    {
+      return this->mtx().try_unlock_upgrade_and_lock_until(abs_time);
+    }
+    bool try_unlock_upgrade_and_lock_for(chrono::nanoseconds const & rel_time)
+    {
+      return this->mtx().try_unlock_upgrade_and_lock_for(rel_time);
+    }
+
+    void unlock_upgrade_and_lock_shared()
+    {
+      this->mtx().unlock_upgrade_and_lock_shared();
+    }
+
+  };
+//]
+
+}
+#endif

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

@@ -4,11 +4,13 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // (C) Copyright 2007-10 Anthony Williams
-// (C) Copyright 2011 Vicente J. Botet Escriba
+// (C) Copyright 2011-2012 Vicente J. Botet Escriba
 
 #include <boost/thread/pthread/timespec.hpp>
 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
 #include <boost/thread/pthread/thread_data.hpp>
+#endif
 #include <boost/thread/pthread/condition_variable_fwd.hpp>
 #ifdef BOOST_THREAD_USES_CHRONO
 #include <boost/chrono/system_clocks.hpp>
@@ -20,10 +22,12 @@
 
 namespace boost
 {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
     namespace this_thread
     {
         void BOOST_THREAD_DECL interruption_point();
     }
+#endif
 
     namespace thread_cv_detail
     {
@@ -53,57 +57,88 @@ namespace boost
 
     inline void condition_variable::wait(unique_lock<mutex>& m)
     {
+#if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
+        if(! m.owns_lock())
+        {
+            boost::throw_exception(condition_error(-1, "boost::condition_variable::wait() failed precondition mutex not owned"));
+        }
+#endif
         int res=0;
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
             detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
             guard.activate(m);
             do {
               res = pthread_cond_wait(&cond,&internal_mutex);
             } while (res == EINTR);
+#else
+            //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+            pthread_mutex_t* the_mutex = m.mutex()->native_handle();
+            do {
+              res = pthread_cond_wait(&cond,the_mutex);
+            } while (res == EINTR);
+#endif
         }
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         this_thread::interruption_point();
+#endif
         if(res)
         {
-            boost::throw_exception(condition_error(res, "boost:: condition_variable constructor failed in pthread_cond_wait"));
+            boost::throw_exception(condition_error(res, "boost::condition_variable::wait failed in pthread_cond_wait"));
         }
     }
 
-    inline bool condition_variable::do_timed_wait(
+    inline bool condition_variable::do_wait_until(
                 unique_lock<mutex>& m,
                 struct timespec const &timeout)
     {
+#if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
         if (!m.owns_lock())
-            boost::throw_exception(condition_error(EPERM, "condition_variable do_timed_wait: mutex not locked"));
-
+        {
+            boost::throw_exception(condition_error(EPERM, "boost::condition_variable::do_wait_until() failed precondition mutex not owned"));
+        }
+#endif
         thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
         int cond_res;
         {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
             guard.activate(m);
             cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+#else
+            //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+            pthread_mutex_t* the_mutex = m.mutex()->native_handle();
+            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
+#endif
         }
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         this_thread::interruption_point();
+#endif
         if(cond_res==ETIMEDOUT)
         {
             return false;
         }
         if(cond_res)
         {
-            boost::throw_exception(condition_error(cond_res, "condition_variable failed in pthread_cond_timedwait"));
+            boost::throw_exception(condition_error(cond_res, "boost::condition_variable::do_wait_until failed in pthread_cond_timedwait"));
         }
         return true;
     }
 
     inline void condition_variable::notify_one() BOOST_NOEXCEPT
     {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+#endif
         BOOST_VERIFY(!pthread_cond_signal(&cond));
     }
 
     inline void condition_variable::notify_all() BOOST_NOEXCEPT
     {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+#endif
         BOOST_VERIFY(!pthread_cond_broadcast(&cond));
     }
 
@@ -119,13 +154,13 @@ namespace boost
             int const res=pthread_mutex_init(&internal_mutex,NULL);
             if(res)
             {
-                boost::throw_exception(thread_resource_error(res, "condition_variable_any failed in pthread_mutex_init"));
+                boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init"));
             }
             int const res2=pthread_cond_init(&cond,NULL);
             if(res2)
             {
                 BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-                boost::throw_exception(thread_resource_error(res, "condition_variable_any failed in pthread_cond_init"));
+                boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_cond_init"));
             }
         }
         ~condition_variable_any()
@@ -140,14 +175,20 @@ namespace boost
             int res=0;
             {
                 thread_cv_detail::lock_on_exit<lock_type> guard;
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+#else
+            boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+#endif
                 guard.activate(m);
                 res=pthread_cond_wait(&cond,&internal_mutex);
             }
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             this_thread::interruption_point();
+#endif
             if(res)
             {
-                boost::throw_exception(condition_error(res, "condition_variable_any failed in pthread_cond_wait"));
+                boost::throw_exception(condition_error(res, "boost::condition_variable_any::wait() failed in pthread_cond_wait"));
             }
         }
 
@@ -157,11 +198,12 @@ namespace boost
             while(!pred()) wait(m);
         }
 
+#if defined BOOST_THREAD_USES_DATETIME
         template<typename lock_type>
         bool timed_wait(lock_type& m,boost::system_time const& wait_until)
         {
-            struct timespec const timeout=detail::get_timespec(wait_until);
-            return do_timed_wait(m, timeout);
+            struct timespec const timeout=detail::to_timespec(wait_until);
+            return do_wait_until(m, timeout);
         }
         template<typename lock_type>
         bool timed_wait(lock_type& m,xtime const& wait_until)
@@ -197,7 +239,7 @@ namespace boost
         {
             return timed_wait(m,get_system_time()+wait_duration,pred);
         }
-
+#endif
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class lock_type,class Duration>
         cv_status
@@ -265,26 +307,26 @@ namespace boost
                 const chrono::duration<Rep, Period>& d,
                 Predicate pred)
         {
-          while (!pred())
-          {
-              if (wait_for(lock, d) == cv_status::timeout)
-                  return pred();
-          }
-          return true;
+          return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
+
+//          while (!pred())
+//          {
+//              if (wait_for(lock, d) == cv_status::timeout)
+//                  return pred();
+//          }
+//          return true;
         }
 
         template <class lock_type>
-        inline void wait_until(
+        cv_status wait_until(
             lock_type& lk,
             chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
         {
             using namespace chrono;
             nanoseconds d = tp.time_since_epoch();
-            timespec ts;
-            seconds s = duration_cast<seconds>(d);
-            ts.tv_sec = static_cast<long>(s.count());
-            ts.tv_nsec = static_cast<long>((d - s).count());
-            do_timed_wait(lk, ts);
+            timespec ts = boost::detail::to_timespec(d);
+            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
+            else return cv_status::timeout;
         }
 #endif
 
@@ -302,25 +344,31 @@ namespace boost
     private: // used by boost::thread::try_join_until
 
         template <class lock_type>
-        inline bool do_timed_wait(
+        inline bool do_wait_until(
           lock_type& m,
           struct timespec const &timeout)
         {
           int res=0;
           {
               thread_cv_detail::lock_on_exit<lock_type> guard;
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
               detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
+#else
+            boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
+#endif
               guard.activate(m);
               res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
           }
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
           this_thread::interruption_point();
+#endif
           if(res==ETIMEDOUT)
           {
               return false;
           }
           if(res)
           {
-              boost::throw_exception(condition_error(res, "condition_variable_any failed in pthread_cond_timedwait"));
+              boost::throw_exception(condition_error(res, "boost::condition_variable_any::do_wait_until() failed in pthread_cond_timedwait"));
           }
           return true;
         }