couchbase 3.0.0 → 3.0.1

data/ext/third_party/asio/asio/include/asio/detail/impl/strand_executor_service.hpp

@@ -20,14 +20,146 @@
 #include "asio/detail/handler_invoke_helpers.hpp"
 #include "asio/detail/recycling_allocator.hpp"
 #include "asio/executor_work_guard.hpp"
+#include "asio/defer.hpp"
+#include "asio/dispatch.hpp"
+#include "asio/post.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
+template <typename F, typename Allocator>
+class strand_executor_service::allocator_binder
+{
+public:
+  typedef Allocator allocator_type;
+
+  allocator_binder(ASIO_MOVE_ARG(F) f, const Allocator& a)
+    : f_(ASIO_MOVE_CAST(F)(f)),
+      allocator_(a)
+  {
+  }
+
+  allocator_binder(const allocator_binder& other)
+    : f_(other.f_),
+      allocator_(other.allocator_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  allocator_binder(allocator_binder&& other)
+    : f_(ASIO_MOVE_CAST(F)(other.f_)),
+      allocator_(ASIO_MOVE_CAST(allocator_type)(other.allocator_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  allocator_type get_allocator() const ASIO_NOEXCEPT
+  {
+    return allocator_;
+  }
+
+  void operator()()
+  {
+    f_();
+  }
+
+private:
+  F f_;
+  allocator_type allocator_;
+};
+
+template <typename Executor>
+class strand_executor_service::invoker<Executor,
+    typename enable_if<
+      execution::is_executor<Executor>::value
+    >::type>
+{
+public:
+  invoker(const implementation_type& impl, Executor& ex)
+    : impl_(impl),
+      executor_(asio::prefer(ex, execution::outstanding_work.tracked))
+  {
+  }
+
+  invoker(const invoker& other)
+    : impl_(other.impl_),
+      executor_(other.executor_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  invoker(invoker&& other)
+    : impl_(ASIO_MOVE_CAST(implementation_type)(other.impl_)),
+      executor_(ASIO_MOVE_CAST(executor_type)(other.executor_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  struct on_invoker_exit
+  {
+    invoker* this_;
+
+    ~on_invoker_exit()
+    {
+      this_->impl_->mutex_->lock();
+      this_->impl_->ready_queue_.push(this_->impl_->waiting_queue_);
+      bool more_handlers = this_->impl_->locked_ =
+        !this_->impl_->ready_queue_.empty();
+      this_->impl_->mutex_->unlock();
+
+      if (more_handlers)
+      {
+        recycling_allocator<void> allocator;
+        execution::execute(
+            asio::prefer(
+              asio::require(this_->executor_,
+                execution::blocking.never),
+            execution::allocator(allocator)),
+            ASIO_MOVE_CAST(invoker)(*this_));
+      }
+    }
+  };
+
+  void operator()()
+  {
+    // Indicate that this strand is executing on the current thread.
+    call_stack<strand_impl>::context ctx(impl_.get());
+
+    // Ensure the next handler, if any, is scheduled on block exit.
+    on_invoker_exit on_exit = { this };
+    (void)on_exit;
+
+    // Run all ready handlers. No lock is required since the ready queue is
+    // accessed only within the strand.
+    asio::error_code ec;
+    while (scheduler_operation* o = impl_->ready_queue_.front())
+    {
+      impl_->ready_queue_.pop();
+      o->complete(impl_.get(), ec, 0);
+    }
+  }
+
+private:
+  typedef typename decay<
+      typename prefer_result<
+        Executor,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type executor_type;
+
+  implementation_type impl_;
+  executor_type executor_;
+};
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
 template <typename Executor>
-class strand_executor_service::invoker
+class strand_executor_service::invoker<Executor,
+    typename enable_if<
+      !execution::is_executor<Executor>::value
+    >::type>
 {
 public:
   invoker(const implementation_type& impl, Executor& ex)
@@ -95,6 +227,68 @@ private:
   executor_work_guard<Executor> work_;
 };
 
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor, typename Function>
+inline void strand_executor_service::execute(const implementation_type& impl,
+    Executor& ex, ASIO_MOVE_ARG(Function) function,
+    typename enable_if<
+      can_query<Executor, execution::allocator_t<void> >::value
+    >::type*)
+{
+  return strand_executor_service::do_execute(impl, ex,
+      ASIO_MOVE_CAST(Function)(function),
+      asio::query(ex, execution::allocator));
+}
+
+template <typename Executor, typename Function>
+inline void strand_executor_service::execute(const implementation_type& impl,
+    Executor& ex, ASIO_MOVE_ARG(Function) function,
+    typename enable_if<
+      !can_query<Executor, execution::allocator_t<void> >::value
+    >::type*)
+{
+  return strand_executor_service::do_execute(impl, ex,
+      ASIO_MOVE_CAST(Function)(function),
+      std::allocator<void>());
+}
+
+template <typename Executor, typename Function, typename Allocator>
+void strand_executor_service::do_execute(const implementation_type& impl,
+    Executor& ex, ASIO_MOVE_ARG(Function) function, const Allocator& a)
+{
+  typedef typename decay<Function>::type function_type;
+
+  // If the executor is not never-blocking, and we are already in the strand,
+  // then the function can run immediately.
+  if (asio::query(ex, execution::blocking) != execution::blocking.never
+      && call_stack<strand_impl>::contains(impl.get()))
+  {
+    // Make a local, non-const copy of the function.
+    function_type tmp(ASIO_MOVE_CAST(Function)(function));
+
+    fenced_block b(fenced_block::full);
+    asio_handler_invoke_helpers::invoke(tmp, tmp);
+    return;
+  }
+
+  // Allocate and construct an operation to wrap the function.
+  typedef executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(function), a);
+
+  ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
+        "strand_executor", impl.get(), 0, "execute"));
+
+  // Add the function to the strand and schedule the strand if required.
+  bool first = enqueue(impl, p.p);
+  p.v = p.p = 0;
+  if (first)
+  {
+    execution::execute(ex, invoker<Executor>(impl, ex));
+  }
+}
+
 template <typename Executor, typename Function, typename Allocator>
 void strand_executor_service::dispatch(const implementation_type& impl,
     Executor& ex, ASIO_MOVE_ARG(Function) function, const Allocator& a)
@@ -124,7 +318,11 @@ void strand_executor_service::dispatch(const implementation_type& impl,
   bool first = enqueue(impl, p.p);
   p.v = p.p = 0;
   if (first)
-    ex.dispatch(invoker<Executor>(impl, ex), a);
+  {
+    asio::dispatch(ex,
+        allocator_binder<invoker<Executor>, Allocator>(
+          invoker<Executor>(impl, ex), a));
+  }
 }
 
 // Request invocation of the given function and return immediately.
@@ -146,7 +344,11 @@ void strand_executor_service::post(const implementation_type& impl,
   bool first = enqueue(impl, p.p);
   p.v = p.p = 0;
   if (first)
-    ex.post(invoker<Executor>(impl, ex), a);
+  {
+    asio::post(ex,
+        allocator_binder<invoker<Executor>, Allocator>(
+          invoker<Executor>(impl, ex), a));
+  }
 }
 
 // Request invocation of the given function and return immediately.
@@ -168,7 +370,11 @@ void strand_executor_service::defer(const implementation_type& impl,
   bool first = enqueue(impl, p.p);
   p.v = p.p = 0;
   if (first)
-    ex.defer(invoker<Executor>(impl, ex), a);
+  {
+    asio::defer(ex,
+        allocator_binder<invoker<Executor>, Allocator>(
+          invoker<Executor>(impl, ex), a));
+  }
 }
 
 } // namespace detail

data/ext/third_party/asio/asio/include/asio/detail/impl/strand_service.hpp

@@ -35,7 +35,7 @@ inline strand_service::strand_impl::strand_impl()
 
 struct strand_service::on_dispatch_exit
 {
-  io_context_impl* io_context_;
+  io_context_impl* io_context_impl_;
   strand_impl* impl_;
 
   ~on_dispatch_exit()
@@ -46,7 +46,7 @@ struct strand_service::on_dispatch_exit
     impl_->mutex_.unlock();
 
     if (more_handlers)
-      io_context_->post_immediate_completion(impl_, false);
+      io_context_impl_->post_immediate_completion(impl_, false);
   }
 };
 
@@ -63,10 +63,10 @@ void strand_service::dispatch(strand_service::implementation_type& impl,
   }
 
   // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler> op;
+  typedef completion_handler<Handler, io_context::executor_type> op;
   typename op::ptr p = { asio::detail::addressof(handler),
     op::ptr::allocate(handler), 0 };
-  p.p = new (p.v) op(handler);
+  p.p = new (p.v) op(handler, io_context_.get_executor());
 
   ASIO_HANDLER_CREATION((this->context(),
         *p.p, "strand", impl, 0, "dispatch"));
@@ -81,11 +81,10 @@ void strand_service::dispatch(strand_service::implementation_type& impl,
     call_stack<strand_impl>::context ctx(impl);
 
     // Ensure the next handler, if any, is scheduled on block exit.
-    on_dispatch_exit on_exit = { &io_context_, impl };
+    on_dispatch_exit on_exit = { &io_context_impl_, impl };
     (void)on_exit;
 
-    completion_handler<Handler>::do_complete(
-        &io_context_, o, asio::error_code(), 0);
+    op::do_complete(&io_context_impl_, o, asio::error_code(), 0);
   }
 }
 
@@ -98,10 +97,10 @@ void strand_service::post(strand_service::implementation_type& impl,
     asio_handler_cont_helpers::is_continuation(handler);
 
   // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler> op;
+  typedef completion_handler<Handler, io_context::executor_type> op;
   typename op::ptr p = { asio::detail::addressof(handler),
     op::ptr::allocate(handler), 0 };
-  p.p = new (p.v) op(handler);
+  p.p = new (p.v) op(handler, io_context_.get_executor());
 
   ASIO_HANDLER_CREATION((this->context(),
         *p.p, "strand", impl, 0, "post"));

data/ext/third_party/asio/asio/include/asio/detail/impl/strand_service.ipp

@@ -43,7 +43,8 @@ struct strand_service::on_do_complete_exit
 
 strand_service::strand_service(asio::io_context& io_context)
   : asio::detail::service_base<strand_service>(io_context),
-    io_context_(asio::use_service<io_context_impl>(io_context)),
+    io_context_(io_context),
+    io_context_impl_(asio::use_service<io_context_impl>(io_context)),
     mutex_(),
     salt_(0)
 {
@@ -94,7 +95,7 @@ bool strand_service::do_dispatch(implementation_type& impl, operation* op)
 {
   // If we are running inside the io_context, and no other handler already
   // holds the strand lock, then the handler can run immediately.
-  bool can_dispatch = io_context_.can_dispatch();
+  bool can_dispatch = io_context_impl_.can_dispatch();
   impl->mutex_.lock();
   if (can_dispatch && !impl->locked_)
   {
@@ -117,7 +118,7 @@ bool strand_service::do_dispatch(implementation_type& impl, operation* op)
     impl->locked_ = true;
     impl->mutex_.unlock();
     impl->ready_queue_.push(op);
-    io_context_.post_immediate_completion(impl, false);
+    io_context_impl_.post_immediate_completion(impl, false);
   }
 
   return false;
@@ -140,7 +141,7 @@ void strand_service::do_post(implementation_type& impl,
     impl->locked_ = true;
     impl->mutex_.unlock();
     impl->ready_queue_.push(op);
-    io_context_.post_immediate_completion(impl, is_continuation);
+    io_context_impl_.post_immediate_completion(impl, is_continuation);
   }
 }
 

data/ext/third_party/asio/asio/include/asio/detail/impl/win_iocp_io_context.ipp

@@ -113,6 +113,7 @@ win_iocp_io_context::~win_iocp_io_context()
 {
   if (thread_.get())
   {
+    stop();
     thread_->join();
     thread_.reset();
   }
@@ -199,7 +200,7 @@ size_t win_iocp_io_context::run(asio::error_code& ec)
   thread_call_stack::context ctx(this, this_thread);
 
   size_t n = 0;
-  while (do_one(INFINITE, ec))
+  while (do_one(INFINITE, this_thread, ec))
     if (n != (std::numeric_limits<size_t>::max)())
       ++n;
   return n;
@@ -217,7 +218,7 @@ size_t win_iocp_io_context::run_one(asio::error_code& ec)
   win_iocp_thread_info this_thread;
   thread_call_stack::context ctx(this, this_thread);
 
-  return do_one(INFINITE, ec);
+  return do_one(INFINITE, this_thread, ec);
 }
 
 size_t win_iocp_io_context::wait_one(long usec, asio::error_code& ec)
@@ -232,7 +233,7 @@ size_t win_iocp_io_context::wait_one(long usec, asio::error_code& ec)
   win_iocp_thread_info this_thread;
   thread_call_stack::context ctx(this, this_thread);
 
-  return do_one(usec < 0 ? INFINITE : ((usec - 1) / 1000 + 1), ec);
+  return do_one(usec < 0 ? INFINITE : ((usec - 1) / 1000 + 1), this_thread, ec);
 }
 
 size_t win_iocp_io_context::poll(asio::error_code& ec)
@@ -248,7 +249,7 @@ size_t win_iocp_io_context::poll(asio::error_code& ec)
   thread_call_stack::context ctx(this, this_thread);
 
   size_t n = 0;
-  while (do_one(0, ec))
+  while (do_one(0, this_thread, ec))
     if (n != (std::numeric_limits<size_t>::max)())
       ++n;
   return n;
@@ -266,7 +267,7 @@ size_t win_iocp_io_context::poll_one(asio::error_code& ec)
   win_iocp_thread_info this_thread;
   thread_call_stack::context ctx(this, this_thread);
 
-  return do_one(0, ec);
+  return do_one(0, this_thread, ec);
 }
 
 void win_iocp_io_context::stop()
@@ -286,6 +287,12 @@ void win_iocp_io_context::stop()
   }
 }
 
+void win_iocp_io_context::capture_current_exception()
+{
+  if (thread_info_base* this_thread = thread_call_stack::contains(this))
+    this_thread->capture_current_exception();
+}
+
 void win_iocp_io_context::post_deferred_completion(win_iocp_operation* op)
 {
   // Flag the operation as ready.
@@ -395,7 +402,8 @@ void win_iocp_io_context::on_completion(win_iocp_operation* op,
   }
 }
 
-size_t win_iocp_io_context::do_one(DWORD msec, asio::error_code& ec)
+size_t win_iocp_io_context::do_one(DWORD msec,
+    win_iocp_thread_info& this_thread, asio::error_code& ec)
 {
   for (;;)
   {
@@ -457,6 +465,7 @@ size_t win_iocp_io_context::do_one(DWORD msec, asio::error_code& ec)
         (void)on_exit;
 
         op->complete(this, result_ec, bytes_transferred);
+        this_thread.rethrow_pending_exception();
         ec = asio::error_code();
         return 1;
       }

data/ext/third_party/asio/asio/include/asio/detail/io_object_impl.hpp

@@ -17,41 +17,17 @@
 
 #include <new>
 #include "asio/detail/config.hpp"
-#include "asio/detail/io_object_executor.hpp"
 #include "asio/detail/type_traits.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/context.hpp"
 #include "asio/io_context.hpp"
+#include "asio/query.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
-
-class executor;
-
 namespace detail {
 
-inline bool is_native_io_executor(const io_context::executor_type&)
-{
-  return true;
-}
-
-template <typename Executor>
-inline bool is_native_io_executor(const Executor&,
-    typename enable_if<!is_same<Executor, executor>::value>::type* = 0)
-{
-  return false;
-}
-
-template <typename Executor>
-inline bool is_native_io_executor(const Executor& ex,
-    typename enable_if<is_same<Executor, executor>::value>::type* = 0)
-{
-#if !defined (ASIO_NO_TYPEID)
-  return ex.target_type() == typeid(io_context::executor_type);
-#else // !defined (ASIO_NO_TYPEID)
-  return false;
-#endif // !defined (ASIO_NO_TYPEID)
-}
-
 template <typename IoObjectService,
     typename Executor = io_context::executor_type>
 class io_object_impl
@@ -66,13 +42,11 @@ public:
   // The type of the executor associated with the object.
   typedef Executor executor_type;
 
-  // The type of executor to be used when implementing asynchronous operations.
-  typedef io_object_executor<Executor> implementation_executor_type;
-
   // Construct an I/O object using an executor.
   explicit io_object_impl(const executor_type& ex)
-    : service_(&asio::use_service<IoObjectService>(ex.context())),
-      implementation_executor_(ex, (is_native_io_executor)(ex))
+    : service_(&asio::use_service<IoObjectService>(
+          io_object_impl::get_context(ex))),
+      executor_(ex)
   {
     service_->construct(implementation_);
   }
@@ -83,8 +57,7 @@ public:
       typename enable_if<is_convertible<
         ExecutionContext&, execution_context&>::value>::type* = 0)
     : service_(&asio::use_service<IoObjectService>(context)),
-      implementation_executor_(context.get_executor(),
-        is_same<ExecutionContext, io_context>::value)
+      executor_(context.get_executor())
   {
     service_->construct(implementation_);
   }
@@ -93,7 +66,7 @@ public:
   // Move-construct an I/O object.
   io_object_impl(io_object_impl&& other)
     : service_(&other.get_service()),
-      implementation_executor_(other.get_implementation_executor())
+      executor_(other.get_executor())
   {
     service_->move_construct(implementation_, other.implementation_);
   }
@@ -102,8 +75,8 @@ public:
   template <typename IoObjectService1, typename Executor1>
   io_object_impl(io_object_impl<IoObjectService1, Executor1>&& other)
     : service_(&asio::use_service<IoObjectService>(
-            other.get_implementation_executor().context())),
-      implementation_executor_(other.get_implementation_executor())
+            io_object_impl::get_context(other.get_executor()))),
+      executor_(other.get_executor())
   {
     service_->converting_move_construct(implementation_,
         other.get_service(), other.get_implementation());
@@ -124,9 +97,9 @@ public:
     {
       service_->move_assign(implementation_,
           *other.service_, other.implementation_);
-      implementation_executor_.~implementation_executor_type();
-      new (&implementation_executor_) implementation_executor_type(
-          std::move(other.implementation_executor_));
+      executor_.~executor_type();
+      new (&executor_) executor_type(
+          std::move(other.executor_));
       service_ = other.service_;
     }
     return *this;
@@ -134,16 +107,9 @@ public:
 #endif // defined(ASIO_HAS_MOVE)
 
   // Get the executor associated with the object.
-  executor_type get_executor() ASIO_NOEXCEPT
+  const executor_type& get_executor() ASIO_NOEXCEPT
   {
-    return implementation_executor_.inner_executor();
-  }
-
-  // Get the executor to be used when implementing asynchronous operations.
-  const implementation_executor_type& get_implementation_executor()
-    ASIO_NOEXCEPT
-  {
-    return implementation_executor_;
+    return executor_;
   }
 
   // Get the service associated with the I/O object.
@@ -171,6 +137,22 @@ public:
   }
 
 private:
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<execution::is_executor<T>::value>::type* = 0)
+  {
+    return asio::query(t, execution::context);
+  }
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<!execution::is_executor<T>::value>::type* = 0)
+  {
+    return t.context();
+  }
+
   // Disallow copying and copy assignment.
   io_object_impl(const io_object_impl&);
   io_object_impl& operator=(const io_object_impl&);
@@ -182,7 +164,7 @@ private:
   implementation_type implementation_;
 
   // The associated executor.
-  implementation_executor_type implementation_executor_;
+  executor_type executor_;
 };
 
 } // namespace detail