passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/{task_io_service.ipp → scheduler.ipp}

@@ -1,15 +1,15 @@
 //
-// detail/impl/task_io_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// detail/impl/scheduler.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
 //
 
-#ifndef BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
-#define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
+#ifndef BOOST_ASIO_DETAIL_IMPL_SCHEDULER_IPP
+#define BOOST_ASIO_DETAIL_IMPL_SCHEDULER_IPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,13 +17,12 @@
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_ASIO_HAS_IOCP)
-
+#include <boost/asio/detail/concurrency_hint.hpp>
 #include <boost/asio/detail/event.hpp>
 #include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/reactor.hpp>
-#include <boost/asio/detail/task_io_service.hpp>
-#include <boost/asio/detail/task_io_service_thread_info.hpp>
+#include <boost/asio/detail/scheduler.hpp>
+#include <boost/asio/detail/scheduler_thread_info.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -31,14 +30,14 @@ namespace boost {
 namespace asio {
 namespace detail {
 
-struct task_io_service::task_cleanup
+struct scheduler::task_cleanup
 {
   ~task_cleanup()
   {
     if (this_thread_->private_outstanding_work > 0)
     {
       boost::asio::detail::increment(
-          task_io_service_->outstanding_work_,
+          scheduler_->outstanding_work_,
           this_thread_->private_outstanding_work);
     }
     this_thread_->private_outstanding_work = 0;
@@ -46,29 +45,29 @@ struct task_io_service::task_cleanup
     // Enqueue the completed operations and reinsert the task at the end of
     // the operation queue.
     lock_->lock();
-    task_io_service_->task_interrupted_ = true;
-    task_io_service_->op_queue_.push(this_thread_->private_op_queue);
-    task_io_service_->op_queue_.push(&task_io_service_->task_operation_);
+    scheduler_->task_interrupted_ = true;
+    scheduler_->op_queue_.push(this_thread_->private_op_queue);
+    scheduler_->op_queue_.push(&scheduler_->task_operation_);
   }
 
-  task_io_service* task_io_service_;
+  scheduler* scheduler_;
   mutex::scoped_lock* lock_;
   thread_info* this_thread_;
 };
 
-struct task_io_service::work_cleanup
+struct scheduler::work_cleanup
 {
   ~work_cleanup()
   {
     if (this_thread_->private_outstanding_work > 1)
     {
       boost::asio::detail::increment(
-          task_io_service_->outstanding_work_,
+          scheduler_->outstanding_work_,
           this_thread_->private_outstanding_work - 1);
     }
     else if (this_thread_->private_outstanding_work < 1)
     {
-      task_io_service_->work_finished();
+      scheduler_->work_finished();
     }
     this_thread_->private_outstanding_work = 0;
 
@@ -76,31 +75,37 @@ struct task_io_service::work_cleanup
     if (!this_thread_->private_op_queue.empty())
     {
       lock_->lock();
-      task_io_service_->op_queue_.push(this_thread_->private_op_queue);
+      scheduler_->op_queue_.push(this_thread_->private_op_queue);
     }
 #endif // defined(BOOST_ASIO_HAS_THREADS)
   }
 
-  task_io_service* task_io_service_;
+  scheduler* scheduler_;
   mutex::scoped_lock* lock_;
   thread_info* this_thread_;
 };
 
-task_io_service::task_io_service(
-    boost::asio::io_service& io_service, std::size_t concurrency_hint)
-  : boost::asio::detail::service_base<task_io_service>(io_service),
-    one_thread_(concurrency_hint == 1),
-    mutex_(),
+scheduler::scheduler(
+    boost::asio::execution_context& ctx, int concurrency_hint)
+  : boost::asio::detail::execution_context_service_base<scheduler>(ctx),
+    one_thread_(concurrency_hint == 1
+        || !BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          SCHEDULER, concurrency_hint)
+        || !BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          REACTOR_IO, concurrency_hint)),
+    mutex_(BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          SCHEDULER, concurrency_hint)),
     task_(0),
     task_interrupted_(true),
     outstanding_work_(0),
     stopped_(false),
-    shutdown_(false)
+    shutdown_(false),
+    concurrency_hint_(concurrency_hint)
 {
   BOOST_ASIO_HANDLER_TRACKING_INIT;
 }
 
-void task_io_service::shutdown_service()
+void scheduler::shutdown()
 {
   mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
@@ -119,18 +124,18 @@ void task_io_service::shutdown_service()
   task_ = 0;
 }
 
-void task_io_service::init_task()
+void scheduler::init_task()
 {
   mutex::scoped_lock lock(mutex_);
   if (!shutdown_ && !task_)
   {
-    task_ = &use_service<reactor>(this->get_io_service());
+    task_ = &use_service<reactor>(this->context());
     op_queue_.push(&task_operation_);
     wake_one_thread_and_unlock(lock);
   }
 }
 
-std::size_t task_io_service::run(boost::system::error_code& ec)
+std::size_t scheduler::run(boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
   if (outstanding_work_ == 0)
@@ -152,7 +157,7 @@ std::size_t task_io_service::run(boost::system::error_code& ec)
   return n;
 }
 
-std::size_t task_io_service::run_one(boost::system::error_code& ec)
+std::size_t scheduler::run_one(boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
   if (outstanding_work_ == 0)
@@ -170,7 +175,25 @@ std::size_t task_io_service::run_one(boost::system::error_code& ec)
   return do_run_one(lock, this_thread, ec);
 }
 
-std::size_t task_io_service::poll(boost::system::error_code& ec)
+std::size_t scheduler::wait_one(long usec, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+  if (outstanding_work_ == 0)
+  {
+    stop();
+    return 0;
+  }
+
+  thread_info this_thread;
+  this_thread.private_outstanding_work = 0;
+  thread_call_stack::context ctx(this, this_thread);
+
+  mutex::scoped_lock lock(mutex_);
+
+  return do_wait_one(lock, this_thread, usec, ec);
+}
+
+std::size_t scheduler::poll(boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
   if (outstanding_work_ == 0)
@@ -190,8 +213,8 @@ std::size_t task_io_service::poll(boost::system::error_code& ec)
   // that are already on a thread-private queue need to be put on to the main
   // queue now.
   if (one_thread_)
-    if (thread_info* outer_thread_info = ctx.next_by_key())
-      op_queue_.push(outer_thread_info->private_op_queue);
+    if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
+      op_queue_.push(outer_info->private_op_queue);
 #endif // defined(BOOST_ASIO_HAS_THREADS)
 
   std::size_t n = 0;
@@ -201,7 +224,7 @@ std::size_t task_io_service::poll(boost::system::error_code& ec)
   return n;
 }
 
-std::size_t task_io_service::poll_one(boost::system::error_code& ec)
+std::size_t scheduler::poll_one(boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
   if (outstanding_work_ == 0)
@@ -221,41 +244,47 @@ std::size_t task_io_service::poll_one(boost::system::error_code& ec)
   // that are already on a thread-private queue need to be put on to the main
   // queue now.
   if (one_thread_)
-    if (thread_info* outer_thread_info = ctx.next_by_key())
-      op_queue_.push(outer_thread_info->private_op_queue);
+    if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
+      op_queue_.push(outer_info->private_op_queue);
 #endif // defined(BOOST_ASIO_HAS_THREADS)
 
   return do_poll_one(lock, this_thread, ec);
 }
 
-void task_io_service::stop()
+void scheduler::stop()
 {
   mutex::scoped_lock lock(mutex_);
   stop_all_threads(lock);
 }
 
-bool task_io_service::stopped() const
+bool scheduler::stopped() const
 {
   mutex::scoped_lock lock(mutex_);
   return stopped_;
 }
 
-void task_io_service::reset()
+void scheduler::restart()
 {
   mutex::scoped_lock lock(mutex_);
   stopped_ = false;
 }
 
-void task_io_service::post_immediate_completion(
-    task_io_service::operation* op, bool is_continuation)
+void scheduler::compensating_work_started()
+{
+  thread_info_base* this_thread = thread_call_stack::contains(this);
+  ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
+}
+
+void scheduler::post_immediate_completion(
+    scheduler::operation* op, bool is_continuation)
 {
 #if defined(BOOST_ASIO_HAS_THREADS)
   if (one_thread_ || is_continuation)
   {
-    if (thread_info* this_thread = thread_call_stack::contains(this))
+    if (thread_info_base* this_thread = thread_call_stack::contains(this))
     {
-      ++this_thread->private_outstanding_work;
-      this_thread->private_op_queue.push(op);
+      ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
+      static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
       return;
     }
   }
@@ -269,14 +298,14 @@ void task_io_service::post_immediate_completion(
   wake_one_thread_and_unlock(lock);
 }
 
-void task_io_service::post_deferred_completion(task_io_service::operation* op)
+void scheduler::post_deferred_completion(scheduler::operation* op)
 {
 #if defined(BOOST_ASIO_HAS_THREADS)
   if (one_thread_)
   {
-    if (thread_info* this_thread = thread_call_stack::contains(this))
+    if (thread_info_base* this_thread = thread_call_stack::contains(this))
     {
-      this_thread->private_op_queue.push(op);
+      static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
       return;
     }
   }
@@ -287,17 +316,17 @@ void task_io_service::post_deferred_completion(task_io_service::operation* op)
   wake_one_thread_and_unlock(lock);
 }
 
-void task_io_service::post_deferred_completions(
-    op_queue<task_io_service::operation>& ops)
+void scheduler::post_deferred_completions(
+    op_queue<scheduler::operation>& ops)
 {
   if (!ops.empty())
   {
 #if defined(BOOST_ASIO_HAS_THREADS)
     if (one_thread_)
     {
-      if (thread_info* this_thread = thread_call_stack::contains(this))
+      if (thread_info_base* this_thread = thread_call_stack::contains(this))
       {
-        this_thread->private_op_queue.push(ops);
+        static_cast<thread_info*>(this_thread)->private_op_queue.push(ops);
         return;
       }
     }
@@ -309,8 +338,8 @@ void task_io_service::post_deferred_completions(
   }
 }
 
-void task_io_service::do_dispatch(
-    task_io_service::operation* op)
+void scheduler::do_dispatch(
+    scheduler::operation* op)
 {
   work_started();
   mutex::scoped_lock lock(mutex_);
@@ -318,15 +347,15 @@ void task_io_service::do_dispatch(
   wake_one_thread_and_unlock(lock);
 }
 
-void task_io_service::abandon_operations(
-    op_queue<task_io_service::operation>& ops)
+void scheduler::abandon_operations(
+    op_queue<scheduler::operation>& ops)
 {
-  op_queue<task_io_service::operation> ops2;
+  op_queue<scheduler::operation> ops2;
   ops2.push(ops);
 }
 
-std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
-    task_io_service::thread_info& this_thread,
+std::size_t scheduler::do_run_one(mutex::scoped_lock& lock,
+    scheduler::thread_info& this_thread,
     const boost::system::error_code& ec)
 {
   while (!stopped_)
@@ -353,7 +382,7 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
         // Run the task. May throw an exception. Only block if the operation
         // queue is empty and we're not polling, otherwise we want to return
         // as soon as possible.
-        task_->run(!more_handlers, this_thread.private_op_queue);
+        task_->run(more_handlers ? 0 : -1, this_thread.private_op_queue);
       }
       else
       {
@@ -369,7 +398,7 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
         (void)on_exit;
 
         // Complete the operation. May throw an exception. Deletes the object.
-        o->complete(*this, ec, task_result);
+        o->complete(this, ec, task_result);
 
         return 1;
       }
@@ -384,8 +413,78 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
   return 0;
 }
 
-std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
-    task_io_service::thread_info& this_thread,
+std::size_t scheduler::do_wait_one(mutex::scoped_lock& lock,
+    scheduler::thread_info& this_thread, long usec,
+    const boost::system::error_code& ec)
+{
+  if (stopped_)
+    return 0;
+
+  operation* o = op_queue_.front();
+  if (o == 0)
+  {
+    wakeup_event_.clear(lock);
+    wakeup_event_.wait_for_usec(lock, usec);
+    usec = 0; // Wait at most once.
+    o = op_queue_.front();
+  }
+
+  if (o == &task_operation_)
+  {
+    op_queue_.pop();
+    bool more_handlers = (!op_queue_.empty());
+
+    task_interrupted_ = more_handlers;
+
+    if (more_handlers && !one_thread_)
+      wakeup_event_.unlock_and_signal_one(lock);
+    else
+      lock.unlock();
+
+    {
+      task_cleanup on_exit = { this, &lock, &this_thread };
+      (void)on_exit;
+
+      // Run the task. May throw an exception. Only block if the operation
+      // queue is empty and we're not polling, otherwise we want to return
+      // as soon as possible.
+      task_->run(more_handlers ? 0 : usec, this_thread.private_op_queue);
+    }
+
+    o = op_queue_.front();
+    if (o == &task_operation_)
+    {
+      if (!one_thread_)
+        wakeup_event_.maybe_unlock_and_signal_one(lock);
+      return 0;
+    }
+  }
+
+  if (o == 0)
+    return 0;
+
+  op_queue_.pop();
+  bool more_handlers = (!op_queue_.empty());
+
+  std::size_t task_result = o->task_result_;
+
+  if (more_handlers && !one_thread_)
+    wake_one_thread_and_unlock(lock);
+  else
+    lock.unlock();
+
+  // Ensure the count of outstanding work is decremented on block exit.
+  work_cleanup on_exit = { this, &lock, &this_thread };
+  (void)on_exit;
+
+  // Complete the operation. May throw an exception. Deletes the object.
+  o->complete(this, ec, task_result);
+
+  return 1;
+}
+
+std::size_t scheduler::do_poll_one(mutex::scoped_lock& lock,
+    scheduler::thread_info& this_thread,
     const boost::system::error_code& ec)
 {
   if (stopped_)
@@ -404,7 +503,7 @@ std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
       // Run the task. May throw an exception. Only block if the operation
       // queue is empty and we're not polling, otherwise we want to return
       // as soon as possible.
-      task_->run(false, this_thread.private_op_queue);
+      task_->run(0, this_thread.private_op_queue);
     }
 
     o = op_queue_.front();
@@ -433,12 +532,12 @@ std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
   (void)on_exit;
 
   // Complete the operation. May throw an exception. Deletes the object.
-  o->complete(*this, ec, task_result);
+  o->complete(this, ec, task_result);
 
   return 1;
 }
 
-void task_io_service::stop_all_threads(
+void scheduler::stop_all_threads(
     mutex::scoped_lock& lock)
 {
   stopped_ = true;
@@ -451,7 +550,7 @@ void task_io_service::stop_all_threads(
   }
 }
 
-void task_io_service::wake_one_thread_and_unlock(
+void scheduler::wake_one_thread_and_unlock(
     mutex::scoped_lock& lock)
 {
   if (!wakeup_event_.maybe_unlock_and_signal_one(lock))
@@ -471,6 +570,4 @@ void task_io_service::wake_one_thread_and_unlock(
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_ASIO_HAS_IOCP)
-
-#endif // BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
+#endif // BOOST_ASIO_DETAIL_IMPL_SCHEDULER_IPP