diff options
Diffstat (limited to '3rdparty/asio/include/asio/impl/thread_pool.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/impl/thread_pool.hpp | 341 |
1 files changed, 275 insertions, 66 deletions
diff --git a/3rdparty/asio/include/asio/impl/thread_pool.hpp b/3rdparty/asio/include/asio/impl/thread_pool.hpp index db7d5c01e36..4a6d9d4ca38 100644 --- a/3rdparty/asio/include/asio/impl/thread_pool.hpp +++ b/3rdparty/asio/include/asio/impl/thread_pool.hpp @@ -2,7 +2,7 @@ // impl/thread_pool.hpp // ~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2021 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) @@ -15,9 +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/recycling_allocator.hpp" +#include "asio/detail/non_const_lvalue.hpp" #include "asio/detail/type_traits.hpp" #include "asio/execution_context.hpp" @@ -31,112 +33,319 @@ 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 pool_; + return scheduler_type(*this); } -inline void -thread_pool::executor_type::on_work_started() const ASIO_NOEXCEPT +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 { - pool_.scheduler_.work_started(); + 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; } -inline void thread_pool::executor_type::on_work_finished() -const ASIO_NOEXCEPT +#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 { - pool_.scheduler_.work_finished(); + if (this != &other) + { + thread_pool* old_thread_pool = pool_; + pool_ = other.pool_; + allocator_ = std::move(other.allocator_); + bits_ = other.bits_; + if (Bits & outstanding_work_tracked) + { + other.pool_ = 0; + if (old_thread_pool) + old_thread_pool->scheduler_.work_finished(); + } + } + return *this; } +#endif // defined(ASIO_HAS_MOVE) -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 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 { - // Make a local, non-const copy of the function. typedef typename decay<Function>::type function_type; - function_type tmp(ASIO_MOVE_CAST(Function)(f)); - // Invoke immediately if we are already inside the thread pool. - if (pool_.scheduler_.can_dispatch()) + // 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()) { - detail::fenced_block b(detail::fenced_block::full); - asio_handler_invoke_helpers::invoke(tmp, tmp); - return; - } + // Make a local, non-const copy of the function. + function_type tmp(ASIO_MOVE_CAST(Function)(f)); - // Construct an allocator to be used for the operation. - typedef typename detail::get_recycling_allocator<Allocator>::type alloc_type; - alloc_type allocator(detail::get_recycling_allocator<Allocator>::get(a)); +#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, alloc_type> op; - typename op::ptr p = { allocator, 0, 0 }; - p.v = p.a.allocate(1); - p.p = new (p.v) op(tmp, allocator); + 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_); - ASIO_HANDLER_CREATION((pool_, *p.p, - "thread_pool", &this->context(), 0, "dispatch")); + 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, false); + pool_->scheduler_.post_immediate_completion(p.p, + (bits_ & relationship_continuation) != 0); 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> +void thread_pool::basic_executor_type<Allocator, + Bits>::do_execute(ASIO_MOVE_ARG(Function) f, true_type) const +{ + // 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(); +} + +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 +{ + 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); +} + +template <typename Function> +struct thread_pool_always_blocking_function_adapter +{ + 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 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 { - // Make a local, non-const copy of the function. typedef typename decay<Function>::type function_type; - function_type tmp(ASIO_MOVE_CAST(Function)(f)); - // Construct an allocator to be used for the operation. - typedef typename detail::get_recycling_allocator<Allocator>::type alloc_type; - alloc_type allocator(detail::get_recycling_allocator<Allocator>::get(a)); + // Invoke immediately if we are already inside the thread pool. + if (pool_->scheduler_.can_dispatch()) + { + // Make a local, non-const copy of the function. + function_type tmp(ASIO_MOVE_CAST(Function)(f)); + + detail::fenced_block b(detail::fenced_block::full); + asio_handler_invoke_helpers::invoke(tmp, tmp); + return; + } // Allocate and construct an operation to wrap the function. - typedef detail::executor_op<function_type, alloc_type> op; - typename op::ptr p = { allocator, 0, 0 }; - p.v = p.a.allocate(1); - p.p = new (p.v) op(tmp, allocator); + 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, "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::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>::post( + ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const { - // Make a local, non-const copy of the function. typedef typename decay<Function>::type function_type; - function_type tmp(ASIO_MOVE_CAST(Function)(f)); - - // Construct an allocator to be used for the operation. - typedef typename detail::get_recycling_allocator<Allocator>::type alloc_type; - alloc_type allocator(detail::get_recycling_allocator<Allocator>::get(a)); // Allocate and construct an operation to wrap the function. - typedef detail::executor_op<function_type, alloc_type> op; - typename op::ptr p = { allocator, 0, 0 }; - p.v = p.a.allocate(1); - p.p = new (p.v) op(tmp, allocator); + 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, "post")); - pool_.scheduler_.post_immediate_completion(p.p, true); + pool_->scheduler_.post_immediate_completion(p.p, false); p.v = p.p = 0; } -inline bool -thread_pool::executor_type::running_in_this_thread() const ASIO_NOEXCEPT +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 { - return pool_.scheduler_.can_dispatch(); + typedef typename decay<Function>::type function_type; + + // Allocate and construct an operation to wrap the function. + 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", pool_, 0, "defer")); + + pool_->scheduler_.post_immediate_completion(p.p, true); + p.v = p.p = 0; } +#endif // !defined(ASIO_NO_TS_EXECUTORS) } // namespace asio |