couchbase 3.0.0.beta.1 → 3.1.0

data/ext/third_party/asio/asio/include/asio/impl/thread_pool.hpp

@@ -15,8 +15,11 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/detail/blocking_executor_op.hpp"
+#include "asio/detail/bulk_executor_op.hpp"
 #include "asio/detail/executor_op.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/non_const_lvalue.hpp"
 #include "asio/detail/recycling_allocator.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/execution_context.hpp"
@@ -31,32 +34,255 @@ thread_pool::get_executor() ASIO_NOEXCEPT
   return executor_type(*this);
 }
 
-inline thread_pool&
-thread_pool::executor_type::context() const ASIO_NOEXCEPT
+inline thread_pool::executor_type
+thread_pool::executor() ASIO_NOEXCEPT
+{
+  return executor_type(*this);
+}
+
+inline thread_pool::scheduler_type
+thread_pool::scheduler() ASIO_NOEXCEPT
+{
+  return scheduler_type(*this);
+}
+
+template <typename Allocator, unsigned int Bits>
+thread_pool::basic_executor_type<Allocator, Bits>&
+thread_pool::basic_executor_type<Allocator, Bits>::operator=(
+    const basic_executor_type& other) ASIO_NOEXCEPT
+{
+  if (this != &other)
+  {
+    thread_pool* old_thread_pool = pool_;
+    pool_ = other.pool_;
+    allocator_ = other.allocator_;
+    bits_ = other.bits_;
+    if (Bits & outstanding_work_tracked)
+    {
+      if (pool_)
+        pool_->scheduler_.work_started();
+      if (old_thread_pool)
+        old_thread_pool->scheduler_.work_finished();
+    }
+  }
+  return *this;
+}
+
+#if defined(ASIO_HAS_MOVE)
+template <typename Allocator, unsigned int Bits>
+thread_pool::basic_executor_type<Allocator, Bits>&
+thread_pool::basic_executor_type<Allocator, Bits>::operator=(
+    basic_executor_type&& other) ASIO_NOEXCEPT
+{
+  if (this != &other)
+  {
+    pool_ = other.pool_;
+    allocator_ = std::move(other.allocator_);
+    bits_ = other.bits_;
+    if (Bits & outstanding_work_tracked)
+      other.pool_ = 0;
+  }
+  return *this;
+}
+#endif // defined(ASIO_HAS_MOVE)
+
+template <typename Allocator, unsigned int Bits>
+inline bool thread_pool::basic_executor_type<Allocator,
+    Bits>::running_in_this_thread() const ASIO_NOEXCEPT
+{
+  return pool_->scheduler_.can_dispatch();
+}
+
+template <typename Allocator, unsigned int Bits>
+template <typename Function>
+void thread_pool::basic_executor_type<Allocator,
+    Bits>::do_execute(ASIO_MOVE_ARG(Function) f, false_type) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Invoke immediately if the blocking.possibly property is enabled and we are
+  // already inside the thread pool.
+  if ((bits_ & blocking_never) == 0 && pool_->scheduler_.can_dispatch())
+  {
+    // Make a local, non-const copy of the function.
+    function_type tmp(ASIO_MOVE_CAST(Function)(f));
+
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(ASIO_NO_EXCEPTIONS)
+    try
+    {
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+       //   && !defined(ASIO_NO_EXCEPTIONS)
+      detail::fenced_block b(detail::fenced_block::full);
+      asio_handler_invoke_helpers::invoke(tmp, tmp);
+      return;
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(ASIO_NO_EXCEPTIONS)
+    }
+    catch (...)
+    {
+      pool_->scheduler_.capture_current_exception();
+      return;
+    }
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+       //   && !defined(ASIO_NO_EXCEPTIONS)
+  }
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(allocator_),
+      op::ptr::allocate(allocator_), 0 };
+  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), allocator_);
+
+  if ((bits_ & relationship_continuation) != 0)
+  {
+    ASIO_HANDLER_CREATION((*pool_, *p.p,
+          "thread_pool", pool_, 0, "execute(blk=never,rel=cont)"));
+  }
+  else
+  {
+    ASIO_HANDLER_CREATION((*pool_, *p.p,
+          "thread_pool", pool_, 0, "execute(blk=never,rel=fork)"));
+  }
+
+  pool_->scheduler_.post_immediate_completion(p.p,
+      (bits_ & relationship_continuation) != 0);
+  p.v = p.p = 0;
+}
+
+template <typename Allocator, unsigned int Bits>
+template <typename Function>
+void thread_pool::basic_executor_type<Allocator,
+    Bits>::do_execute(ASIO_MOVE_ARG(Function) f, true_type) const
 {
-  return pool_;
+  // Obtain a non-const instance of the function.
+  detail::non_const_lvalue<Function> f2(f);
+
+  // Invoke immediately if we are already inside the thread pool.
+  if (pool_->scheduler_.can_dispatch())
+  {
+#if !defined(ASIO_NO_EXCEPTIONS)
+    try
+    {
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+      detail::fenced_block b(detail::fenced_block::full);
+      asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+      return;
+#if !defined(ASIO_NO_EXCEPTIONS)
+    }
+    catch (...)
+    {
+      std::terminate();
+    }
+#endif // !defined(ASIO_NO_EXCEPTIONS)
+  }
+
+  // Construct an operation to wrap the function.
+  typedef typename decay<Function>::type function_type;
+  detail::blocking_executor_op<function_type> op(f2.value);
+
+  ASIO_HANDLER_CREATION((*pool_, op,
+        "thread_pool", pool_, 0, "execute(blk=always)"));
+
+  pool_->scheduler_.post_immediate_completion(&op, false);
+  op.wait();
 }
 
-inline void
-thread_pool::executor_type::on_work_started() const ASIO_NOEXCEPT
+template <typename Allocator, unsigned int Bits>
+template <typename Function>
+void thread_pool::basic_executor_type<Allocator, Bits>::do_bulk_execute(
+    ASIO_MOVE_ARG(Function) f, std::size_t n, false_type) const
 {
-  pool_.scheduler_.work_started();
+  typedef typename decay<Function>::type function_type;
+  typedef detail::bulk_executor_op<function_type, Allocator> op;
+
+  // Allocate and construct operations to wrap the function.
+  detail::op_queue<detail::scheduler_operation> ops;
+  for (std::size_t i = 0; i < n; ++i)
+  {
+    typename op::ptr p = { detail::addressof(allocator_),
+        op::ptr::allocate(allocator_), 0 };
+    p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), allocator_, i);
+    ops.push(p.p);
+
+    if ((bits_ & relationship_continuation) != 0)
+    {
+      ASIO_HANDLER_CREATION((*pool_, *p.p,
+            "thread_pool", pool_, 0, "bulk_execute(blk=never,rel=cont)"));
+    }
+    else
+    {
+      ASIO_HANDLER_CREATION((*pool_, *p.p,
+            "thread_pool", pool_, 0, "bulk)execute(blk=never,rel=fork)"));
+    }
+
+    p.v = p.p = 0;
+  }
+
+  pool_->scheduler_.post_immediate_completions(n,
+      ops, (bits_ & relationship_continuation) != 0);
 }
 
-inline void thread_pool::executor_type::on_work_finished()
-const ASIO_NOEXCEPT
+template <typename Function>
+struct thread_pool_always_blocking_function_adapter
 {
-  pool_.scheduler_.work_finished();
+  typename decay<Function>::type* f;
+  std::size_t n;
+
+  void operator()()
+  {
+    for (std::size_t i = 0; i < n; ++i)
+    {
+      (*f)(i);
+    }
+  }
+};
+
+template <typename Allocator, unsigned int Bits>
+template <typename Function>
+void thread_pool::basic_executor_type<Allocator, Bits>::do_bulk_execute(
+    ASIO_MOVE_ARG(Function) f, std::size_t n, true_type) const
+{
+  // Obtain a non-const instance of the function.
+  detail::non_const_lvalue<Function> f2(f);
+
+  thread_pool_always_blocking_function_adapter<Function>
+    adapter = { detail::addressof(f2.value), n };
+
+  this->do_execute(adapter, true_type());
+}
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+template <typename Allocator, unsigned int Bits>
+inline thread_pool& thread_pool::basic_executor_type<
+    Allocator, Bits>::context() const ASIO_NOEXCEPT
+{
+  return *pool_;
+}
+
+template <typename Allocator, unsigned int Bits>
+inline void thread_pool::basic_executor_type<Allocator,
+    Bits>::on_work_started() const ASIO_NOEXCEPT
+{
+  pool_->scheduler_.work_started();
 }
 
-template <typename Function, typename Allocator>
-void thread_pool::executor_type::dispatch(
-    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+template <typename Allocator, unsigned int Bits>
+inline void thread_pool::basic_executor_type<Allocator,
+    Bits>::on_work_finished() const ASIO_NOEXCEPT
+{
+  pool_->scheduler_.work_finished();
+}
+
+template <typename Allocator, unsigned int Bits>
+template <typename Function, typename OtherAllocator>
+void thread_pool::basic_executor_type<Allocator, Bits>::dispatch(
+    ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
 {
   typedef typename decay<Function>::type function_type;
 
   // Invoke immediately if we are already inside the thread pool.
-  if (pool_.scheduler_.can_dispatch())
+  if (pool_->scheduler_.can_dispatch())
   {
     // Make a local, non-const copy of the function.
     function_type tmp(ASIO_MOVE_CAST(Function)(f));
@@ -67,58 +293,55 @@ void thread_pool::executor_type::dispatch(
   }
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
 
-  ASIO_HANDLER_CREATION((pool_, *p.p,
-        "thread_pool", &this->context(), 0, "dispatch"));
+  ASIO_HANDLER_CREATION((*pool_, *p.p,
+        "thread_pool", pool_, 0, "dispatch"));
 
-  pool_.scheduler_.post_immediate_completion(p.p, false);
+  pool_->scheduler_.post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
-template <typename Function, typename Allocator>
-void thread_pool::executor_type::post(
-    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+template <typename Allocator, unsigned int Bits>
+template <typename Function, typename OtherAllocator>
+void thread_pool::basic_executor_type<Allocator, Bits>::post(
+    ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
 {
   typedef typename decay<Function>::type function_type;
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
 
-  ASIO_HANDLER_CREATION((pool_, *p.p,
-        "thread_pool", &this->context(), 0, "post"));
+  ASIO_HANDLER_CREATION((*pool_, *p.p,
+        "thread_pool", pool_, 0, "post"));
 
-  pool_.scheduler_.post_immediate_completion(p.p, false);
+  pool_->scheduler_.post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
-template <typename Function, typename Allocator>
-void thread_pool::executor_type::defer(
-    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+template <typename Allocator, unsigned int Bits>
+template <typename Function, typename OtherAllocator>
+void thread_pool::basic_executor_type<Allocator, Bits>::defer(
+    ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
 {
   typedef typename decay<Function>::type function_type;
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
 
-  ASIO_HANDLER_CREATION((pool_, *p.p,
-        "thread_pool", &this->context(), 0, "defer"));
+  ASIO_HANDLER_CREATION((*pool_, *p.p,
+        "thread_pool", pool_, 0, "defer"));
 
-  pool_.scheduler_.post_immediate_completion(p.p, true);
+  pool_->scheduler_.post_immediate_completion(p.p, true);
   p.v = p.p = 0;
 }
-
-inline bool
-thread_pool::executor_type::running_in_this_thread() const ASIO_NOEXCEPT
-{
-  return pool_.scheduler_.can_dispatch();
-}
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
 
 } // namespace asio
 

data/ext/third_party/asio/asio/include/asio/impl/thread_pool.ipp

@@ -16,7 +16,9 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include <stdexcept>
 #include "asio/thread_pool.hpp"
+#include "asio/detail/throw_exception.hpp"
 
 #include "asio/detail/push_options.hpp"
 
@@ -28,29 +30,68 @@ struct thread_pool::thread_function
 
   void operator()()
   {
-    asio::error_code ec;
-    scheduler_->run(ec);
+#if !defined(ASIO_NO_EXCEPTIONS)
+    try
+    {
+#endif// !defined(ASIO_NO_EXCEPTIONS)
+      asio::error_code ec;
+      scheduler_->run(ec);
+#if !defined(ASIO_NO_EXCEPTIONS)
+    }
+    catch (...)
+    {
+      std::terminate();
+    }
+#endif// !defined(ASIO_NO_EXCEPTIONS)
   }
 };
 
+#if !defined(ASIO_NO_TS_EXECUTORS)
+namespace detail {
+
+inline long default_thread_pool_size()
+{
+  std::size_t num_threads = thread::hardware_concurrency() * 2;
+  num_threads = num_threads == 0 ? 2 : num_threads;
+  return static_cast<long>(num_threads);
+}
+
+} // namespace detail
+
 thread_pool::thread_pool()
-  : scheduler_(add_scheduler(new detail::scheduler(*this, 0, false)))
+  : scheduler_(add_scheduler(new detail::scheduler(*this, 0, false))),
+    num_threads_(detail::default_thread_pool_size())
 {
   scheduler_.work_started();
 
   thread_function f = { &scheduler_ };
-  std::size_t num_threads = detail::thread::hardware_concurrency() * 2;
-  threads_.create_threads(f, num_threads ? num_threads : 2);
+  threads_.create_threads(f, static_cast<std::size_t>(num_threads_));
 }
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
+namespace detail {
+
+inline long clamp_thread_pool_size(std::size_t n)
+{
+  if (n > 0x7FFFFFFF)
+  {
+    std::out_of_range ex("thread pool size");
+    asio::detail::throw_exception(ex);
+  }
+  return static_cast<long>(n & 0x7FFFFFFF);
+}
+
+} // namespace detail
 
 thread_pool::thread_pool(std::size_t num_threads)
   : scheduler_(add_scheduler(new detail::scheduler(
-          *this, num_threads == 1 ? 1 : 0, false)))
+          *this, num_threads == 1 ? 1 : 0, false))),
+    num_threads_(detail::clamp_thread_pool_size(num_threads))
 {
   scheduler_.work_started();
 
   thread_function f = { &scheduler_ };
-  threads_.create_threads(f, num_threads);
+  threads_.create_threads(f, static_cast<std::size_t>(num_threads_));
 }
 
 thread_pool::~thread_pool()
@@ -64,6 +105,13 @@ void thread_pool::stop()
   scheduler_.stop();
 }
 
+void thread_pool::attach()
+{
+  ++num_threads_;
+  thread_function f = { &scheduler_ };
+  f();
+}
+
 void thread_pool::join()
 {
   if (!threads_.empty())
@@ -80,6 +128,12 @@ detail::scheduler& thread_pool::add_scheduler(detail::scheduler* s)
   return *scoped_impl.release();
 }
 
+void thread_pool::wait()
+{
+  scheduler_.work_finished();
+  threads_.join();
+}
+
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"