passenger 6.0.16 → 6.0.18

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/parallel_group.hpp

@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <atomic>
+#include <deque>
 #include <memory>
 #include <new>
 #include <tuple>
@@ -393,6 +394,342 @@ void parallel_group_launch(Condition cancellation_condition, Handler handler,
         Condition, Handler, Ops...> >(state);
 }
 
+// Proxy completion handler for the ranged group of parallel operatations.
+// Unpacks and recombines the individual operations' results, and invokes the
+// user's completion handler.
+template <typename Handler, typename Op, typename Allocator>
+struct ranged_parallel_group_completion_handler
+{
+  typedef typename decay<
+      typename prefer_result<
+        typename associated_executor<Handler>::type,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type executor_type;
+
+  typedef typename parallel_op_signature_as_tuple<
+      typename completion_signature_of<Op>::type
+    >::type op_tuple_type;
+
+  typedef parallel_group_op_result<op_tuple_type> op_result_type;
+
+  ranged_parallel_group_completion_handler(Handler&& h,
+      std::size_t size, const Allocator& allocator)
+    : handler_(std::move(h)),
+      executor_(
+          boost::asio::prefer(
+            boost::asio::get_associated_executor(handler_),
+            execution::outstanding_work.tracked)),
+      allocator_(allocator),
+      completion_order_(size, 0,
+          BOOST_ASIO_REBIND_ALLOC(Allocator, std::size_t)(allocator)),
+      args_(BOOST_ASIO_REBIND_ALLOC(Allocator, op_result_type)(allocator))
+  {
+    for (std::size_t i = 0; i < size; ++i)
+      args_.emplace_back();
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return executor_;
+  }
+
+  void operator()()
+  {
+    this->invoke(
+        boost::asio::detail::make_index_sequence<
+          std::tuple_size<op_tuple_type>::value>());
+  }
+
+  template <std::size_t... I>
+  void invoke(boost::asio::detail::index_sequence<I...>)
+  {
+    typedef typename parallel_op_signature_as_tuple<
+        typename ranged_parallel_group_signature<
+          typename completion_signature_of<Op>::type,
+          Allocator
+        >::raw_type
+      >::type vectors_type;
+
+    // Construct all result vectors using the supplied allocator.
+    vectors_type vectors{
+        typename std::tuple_element<I, vectors_type>::type(
+          BOOST_ASIO_REBIND_ALLOC(Allocator, int)(allocator_))...};
+
+    // Reserve sufficient space in each of the result vectors.
+    int reserve_fold[] = { 0,
+      ( std::get<I>(vectors).reserve(completion_order_.size()),
+        0 )...
+    };
+    (void)reserve_fold;
+
+    // Copy the results from all operations into the result vectors.
+    for (std::size_t idx = 0; idx < completion_order_.size(); ++idx)
+    {
+      int pushback_fold[] = { 0,
+        ( std::get<I>(vectors).push_back(
+            std::move(std::get<I>(args_[idx].get()))),
+          0 )...
+      };
+      (void)pushback_fold;
+    }
+
+    std::move(handler_)(completion_order_, std::move(std::get<I>(vectors))...);
+  }
+
+  Handler handler_;
+  executor_type executor_;
+  Allocator allocator_;
+  std::vector<std::size_t,
+    BOOST_ASIO_REBIND_ALLOC(Allocator, std::size_t)> completion_order_;
+  std::deque<op_result_type,
+    BOOST_ASIO_REBIND_ALLOC(Allocator, op_result_type)> args_;
+};
+
+// Shared state for the parallel group.
+template <typename Condition, typename Handler, typename Op, typename Allocator>
+struct ranged_parallel_group_state
+{
+  ranged_parallel_group_state(Condition&& c, Handler&& h,
+      std::size_t size, const Allocator& allocator)
+    : cancellations_requested_(size),
+      outstanding_(size),
+      cancellation_signals_(
+          BOOST_ASIO_REBIND_ALLOC(Allocator,
+            boost::asio::cancellation_signal)(allocator)),
+      cancellation_condition_(std::move(c)),
+      handler_(std::move(h), size, allocator)
+  {
+    for (std::size_t i = 0; i < size; ++i)
+      cancellation_signals_.emplace_back();
+  }
+
+  // The number of operations that have completed so far. Used to determine the
+  // order of completion.
+  std::atomic<unsigned int> completed_{0};
+
+  // The non-none cancellation type that resulted from a cancellation condition.
+  // Stored here for use by the group's initiating function.
+  std::atomic<cancellation_type_t> cancel_type_{cancellation_type::none};
+
+  // The number of cancellations that have been requested, either on completion
+  // of the operations within the group, or via the cancellation slot for the
+  // group operation. Initially set to the number of operations to prevent
+  // cancellation signals from being emitted until after all of the group's
+  // operations' initiating functions have completed.
+  std::atomic<unsigned int> cancellations_requested_;
+
+  // The number of operations that are yet to complete. Used to determine when
+  // it is safe to invoke the user's completion handler.
+  std::atomic<unsigned int> outstanding_;
+
+  // The cancellation signals for each operation in the group.
+  std::deque<boost::asio::cancellation_signal,
+    BOOST_ASIO_REBIND_ALLOC(Allocator, boost::asio::cancellation_signal)>
+      cancellation_signals_;
+
+  // The cancellation condition is used to determine whether the results from an
+  // individual operation warrant a cancellation request for the whole group.
+  Condition cancellation_condition_;
+
+  // The proxy handler to be invoked once all operations in the group complete.
+  ranged_parallel_group_completion_handler<Handler, Op, Allocator> handler_;
+};
+
+// Handler for an individual operation within the parallel group.
+template <typename Condition, typename Handler, typename Op, typename Allocator>
+struct ranged_parallel_group_op_handler
+{
+  typedef boost::asio::cancellation_slot cancellation_slot_type;
+
+  ranged_parallel_group_op_handler(
+      std::shared_ptr<ranged_parallel_group_state<
+        Condition, Handler, Op, Allocator> > state,
+      std::size_t idx)
+    : state_(std::move(state)),
+      idx_(idx)
+  {
+  }
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return state_->cancellation_signals_[idx_].slot();
+  }
+
+  template <typename... Args>
+  void operator()(Args... args)
+  {
+    // Capture this operation into the completion order.
+    state_->handler_.completion_order_[state_->completed_++] = idx_;
+
+    // Determine whether the results of this operation require cancellation of
+    // the whole group.
+    cancellation_type_t cancel_type = state_->cancellation_condition_(args...);
+
+    // Capture the result of the operation into the proxy completion handler.
+    state_->handler_.args_[idx_].emplace(std::move(args)...);
+
+    if (cancel_type != cancellation_type::none)
+    {
+      // Save the type for potential use by the group's initiating function.
+      state_->cancel_type_ = cancel_type;
+
+      // If we are the first operation to request cancellation, emit a signal
+      // for each operation in the group.
+      if (state_->cancellations_requested_++ == 0)
+        for (std::size_t i = 0; i < state_->cancellation_signals_.size(); ++i)
+          if (i != idx_)
+            state_->cancellation_signals_[i].emit(cancel_type);
+    }
+
+    // If this is the last outstanding operation, invoke the user's handler.
+    if (--state_->outstanding_ == 0)
+      boost::asio::dispatch(std::move(state_->handler_));
+  }
+
+  std::shared_ptr<ranged_parallel_group_state<
+    Condition, Handler, Op, Allocator> > state_;
+  std::size_t idx_;
+};
+
+// Handler for an individual operation within the parallel group that has an
+// explicitly specified executor.
+template <typename Executor, typename Condition,
+    typename Handler, typename Op, typename Allocator>
+struct ranged_parallel_group_op_handler_with_executor :
+  ranged_parallel_group_op_handler<Condition, Handler, Op, Allocator>
+{
+  typedef ranged_parallel_group_op_handler<
+    Condition, Handler, Op, Allocator> base_type;
+  typedef boost::asio::cancellation_slot cancellation_slot_type;
+  typedef Executor executor_type;
+
+  ranged_parallel_group_op_handler_with_executor(
+      std::shared_ptr<ranged_parallel_group_state<
+        Condition, Handler, Op, Allocator> > state,
+      executor_type ex, std::size_t idx)
+    : ranged_parallel_group_op_handler<Condition, Handler, Op, Allocator>(
+        std::move(state), idx)
+  {
+    cancel_proxy_ =
+      &this->state_->cancellation_signals_[idx].slot().template
+        emplace<cancel_proxy>(this->state_, std::move(ex));
+  }
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return cancel_proxy_->signal_.slot();
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return cancel_proxy_->executor_;
+  }
+
+  // Proxy handler that forwards the emitted signal to the correct executor.
+  struct cancel_proxy
+  {
+    cancel_proxy(
+        std::shared_ptr<ranged_parallel_group_state<
+          Condition, Handler, Op, Allocator> > state,
+        executor_type ex)
+      : state_(std::move(state)),
+        executor_(std::move(ex))
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (auto state = state_.lock())
+      {
+        boost::asio::cancellation_signal* sig = &signal_;
+        boost::asio::dispatch(executor_,
+            [state, sig, type]{ sig->emit(type); });
+      }
+    }
+
+    std::weak_ptr<ranged_parallel_group_state<
+      Condition, Handler, Op, Allocator> > state_;
+    boost::asio::cancellation_signal signal_;
+    executor_type executor_;
+  };
+
+  cancel_proxy* cancel_proxy_;
+};
+
+template <typename Condition, typename Handler, typename Op, typename Allocator>
+struct ranged_parallel_group_cancellation_handler
+{
+  ranged_parallel_group_cancellation_handler(
+      std::shared_ptr<ranged_parallel_group_state<
+        Condition, Handler, Op, Allocator> > state)
+    : state_(std::move(state))
+  {
+  }
+
+  void operator()(cancellation_type_t cancel_type)
+  {
+    // If we are the first place to request cancellation, i.e. no operation has
+    // yet completed and requested cancellation, emit a signal for each
+    // operation in the group.
+    if (cancel_type != cancellation_type::none)
+      if (auto state = state_.lock())
+        if (state->cancellations_requested_++ == 0)
+          for (std::size_t i = 0; i < state->cancellation_signals_.size(); ++i)
+            state->cancellation_signals_[i].emit(cancel_type);
+  }
+
+  std::weak_ptr<ranged_parallel_group_state<
+    Condition, Handler, Op, Allocator> > state_;
+};
+
+template <typename Condition, typename Handler,
+    typename Range, typename Allocator>
+void ranged_parallel_group_launch(Condition cancellation_condition,
+    Handler handler, Range&& range, const Allocator& allocator)
+{
+  // Get the user's completion handler's cancellation slot, so that we can allow
+  // cancellation of the entire group.
+  typename associated_cancellation_slot<Handler>::type slot
+          = boost::asio::get_associated_cancellation_slot(handler);
+
+  // The type of the asynchronous operation.
+  typedef typename std::decay<decltype(
+      *std::declval<typename Range::iterator>())>::type op_type;
+
+  // Create the shared state for the operation.
+  typedef ranged_parallel_group_state<Condition,
+    Handler, op_type, Allocator> state_type;
+  std::shared_ptr<state_type> state = std::allocate_shared<state_type>(
+      boost::asio::detail::recycling_allocator<state_type,
+        boost::asio::detail::thread_info_base::parallel_group_tag>(),
+      std::move(cancellation_condition),
+      std::move(handler), range.size(), allocator);
+
+  std::size_t idx = 0;
+  for (auto&& op : std::forward<Range>(range))
+  {
+    typedef typename associated_executor<op_type>::type ex_type;
+    ex_type ex = boost::asio::get_associated_executor(op);
+    std::move(op)(
+        ranged_parallel_group_op_handler_with_executor<
+          ex_type, Condition, Handler, op_type, Allocator>(
+            state, std::move(ex), idx++));
+  }
+
+  // Check if any of the operations has already requested cancellation, and if
+  // so, emit a signal for each operation in the group.
+  if ((state->cancellations_requested_ -= range.size()) > 0)
+    for (auto& signal : state->cancellation_signals_)
+      signal.emit(state->cancel_type_);
+
+  // Register a handler with the user's completion handler's cancellation slot.
+  if (slot.is_connected())
+    slot.template emplace<
+      ranged_parallel_group_cancellation_handler<
+        Condition, Handler, op_type, Allocator> >(state);
+}
+
 } // namespace detail
 } // namespace experimental
 
@@ -403,10 +740,47 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const experimental::detail::parallel_group_completion_handler<
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const experimental::detail::parallel_group_completion_handler<
+        Handler, Ops...>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const experimental::detail::parallel_group_completion_handler<
         Handler, Ops...>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+template <template <typename, typename> class Associator, typename Handler,
+    typename Op, typename Allocator, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::ranged_parallel_group_completion_handler<
+      Handler, Op, Allocator>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const experimental::detail::ranged_parallel_group_completion_handler<
+        Handler, Op, Allocator>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const experimental::detail::ranged_parallel_group_completion_handler<
+        Handler, Op, Allocator>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/promise.hpp

@@ -15,10 +15,10 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/detail/config.hpp>
 #include <boost/asio/cancellation_signal.hpp>
-#include <boost/asio/experimental/detail/completion_handler_erasure.hpp>
+#include <boost/asio/detail/utility.hpp>
 #include <tuple>
-#include <optional>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -26,51 +26,171 @@ namespace boost {
 namespace asio {
 namespace experimental {
 
-template<typename Signature = void(), typename Executor = any_io_executor>
+template<typename Signature = void(),
+    typename Executor = boost::asio::any_io_executor,
+    typename Allocator = std::allocator<void>>
 struct promise;
 
 namespace detail {
 
-template<typename Signature, typename Executor>
+template<typename Signature, typename Executor, typename Allocator>
 struct promise_impl;
 
-template<typename ... Ts, typename Executor>
-struct promise_impl<void(Ts...), Executor>
+template<typename... Ts, typename Executor, typename Allocator>
+struct promise_impl<void(Ts...), Executor, Allocator>
 {
   using result_type = std::tuple<Ts...>;
 
-  promise_impl(Executor executor = {})
-    : executor(std::move(executor))
+  promise_impl(Allocator allocator, Executor executor)
+    : allocator(std::move(allocator)), executor(std::move(executor))
   {
   }
 
-  std::optional<result_type> result;
-  bool done{false};
-  detail::completion_handler_erasure<void(Ts...), Executor> completion;
+  promise_impl(const promise_impl&) = delete;
+
+  ~promise_impl()
+  {
+    if (completion)
+      this->cancel_();
+
+    if (done)
+      reinterpret_cast<result_type*>(&result)->~result_type();
+  }
+
+  typename aligned_storage<sizeof(result_type),
+    alignof(result_type)>::type result;
+  std::atomic<bool> done{false};
   cancellation_signal cancel;
+  Allocator allocator;
   Executor executor;
-};
 
-template<typename Signature = void(), typename Executor = any_io_executor>
-struct promise_handler;
+  template<typename Func, std::size_t... Idx>
+  void apply_impl(Func f, boost::asio::detail::index_sequence<Idx...>)
+  {
+    auto& result_type = *reinterpret_cast<promise_impl::result_type*>(&result);
+    f(std::get<Idx>(std::move(result_type))...);
+  }
+
+  using allocator_type = Allocator;
+  allocator_type get_allocator() {return allocator;}
+
+  using executor_type = Executor;
+  executor_type get_executor() {return executor;}
+
+  template<typename Func>
+  void apply(Func f)
+  {
+    apply_impl(std::forward<Func>(f),
+        boost::asio::detail::make_index_sequence<sizeof...(Ts)>{});
+  }
+
+  struct completion_base
+  {
+    virtual void invoke(Ts&&...ts) = 0;
+  };
+
+  template<typename Alloc, typename WaitHandler_>
+  struct completion_impl final : completion_base
+  {
+    WaitHandler_ handler;
+    Alloc allocator;
+    void invoke(Ts&&... ts)
+    {
+      auto h = std::move(handler);
+
+      using alloc_t = typename std::allocator_traits<
+        typename boost::asio::decay<Alloc>::type>::template
+          rebind_alloc<completion_impl>;
+
+      alloc_t alloc_{allocator};
+      this->~completion_impl();
+      std::allocator_traits<alloc_t>::deallocate(alloc_, this, 1u);
+      std::move(h)(std::forward<Ts>(ts)...);
+    }
+
+    template<typename Alloc_, typename Handler_>
+    completion_impl(Alloc_&& alloc, Handler_&& wh)
+      : handler(std::forward<Handler_>(wh)),
+        allocator(std::forward<Alloc_>(alloc))
+    {
+    }
+  };
+
+  completion_base* completion = nullptr;
+  typename boost::asio::aligned_storage<sizeof(void*) * 4,
+    alignof(completion_base)>::type completion_opt;
+
+  template<typename Alloc, typename Handler>
+  void set_completion(Alloc&& alloc, Handler&& handler)
+  {
+    if (completion)
+      cancel_();
+
+    using impl_t = completion_impl<
+      typename boost::asio::decay<Alloc>::type, Handler>;
+    using alloc_t = typename std::allocator_traits<
+      typename boost::asio::decay<Alloc>::type>::template rebind_alloc<impl_t>;
+
+    alloc_t alloc_{alloc};
+    auto p = std::allocator_traits<alloc_t>::allocate(alloc_, 1u);
+    completion = new (p) impl_t(std::forward<Alloc>(alloc),
+        std::forward<Handler>(handler));
+  }
+
+  template<typename... T_>
+  void complete(T_&&... ts)
+  {
+    assert(completion);
+    std::exchange(completion, nullptr)->invoke(std::forward<T_>(ts)...);
+  }
 
-template<typename Signature, typename Executor>
+  template<typename... T_>
+  void cancel_impl_(std::exception_ptr*, T_*...)
+  {
+    complete(
+        std::make_exception_ptr(
+          boost::system::system_error(
+            boost::asio::error::operation_aborted)),
+        T_{}...);
+  }
+
+  template<typename... T_>
+  void cancel_impl_(boost::system::error_code*, T_*...)
+  {
+    complete(boost::asio::error::operation_aborted, T_{}...);
+  }
+
+  template<typename... T_>
+  void cancel_impl_(T_*...)
+  {
+    complete(T_{}...);
+  }
+
+  void cancel_()
+  {
+    cancel_impl_(static_cast<Ts*>(nullptr)...);
+  }
+};
+
+template<typename Signature = void(),
+    typename Executor = boost::asio::any_io_executor,
+    typename Allocator = any_io_executor>
 struct promise_handler;
 
-template<typename ... Ts, typename Executor>
-struct promise_handler<void(Ts...), Executor>
+template<typename... Ts,  typename Executor, typename Allocator>
+struct promise_handler<void(Ts...), Executor, Allocator>
 {
-  using promise_type = promise<void(Ts...), Executor>;
+  using promise_type = promise<void(Ts...), Executor, Allocator>;
 
-  promise_handler(Executor executor) // get_associated_allocator(exec)
-    : impl_{
-        std::allocate_shared<promise_impl<void(Ts...), Executor>>(
-          get_associated_allocator(executor))}
+  promise_handler(
+      Allocator allocator, Executor executor) // get_associated_allocator(exec)
+    : impl_(
+        std::allocate_shared<promise_impl<void(Ts...), Executor, Allocator>>(
+          allocator, allocator, executor))
   {
-    impl_->executor = std::move(executor);
   }
 
-  std::shared_ptr<promise_impl<void(Ts...), Executor>> impl_;
+  std::shared_ptr<promise_impl<void(Ts...), Executor, Allocator>> impl_;
 
   using cancellation_slot_type = cancellation_slot;
 
@@ -79,18 +199,37 @@ struct promise_handler<void(Ts...), Executor>
     return impl_->cancel.slot();
   }
 
-  auto make_promise() -> promise<void(Ts...), Executor>
+  using allocator_type = Allocator;
+
+  allocator_type get_allocator() const noexcept
+  {
+    return impl_->get_allocator();
+  }
+
+  using executor_type = Executor;
+
+  Executor get_executor() const noexcept
   {
-    return {impl_};
+    return impl_->get_executor();
+  }
+
+  auto make_promise() -> promise<void(Ts...), executor_type, allocator_type>
+  {
+    return promise<void(Ts...), executor_type, allocator_type>{impl_};
   }
 
   void operator()(std::remove_reference_t<Ts>... ts)
   {
     assert(impl_);
-    impl_->result.emplace(std::move(ts)...);
+
+    using result_type = typename promise_impl<
+      void(Ts...), allocator_type, executor_type>::result_type ;
+
+    new (&impl_->result) result_type(std::move(ts)...);
     impl_->done = true;
-    if (auto f = std::exchange(impl_->completion, nullptr); f != nullptr)
-      std::apply(std::move(f), std::move(*impl_->result));
+
+    if (impl_->completion)
+      impl_->complete(std::move(ts)...);
   }
 };