125 lines
3.0 KiB
C++
125 lines
3.0 KiB
C++
//
|
|
// detail/impl/resolver_thread_pool.ipp
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
// Copyright (c) 2003-2025 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 ASIO_DETAIL_IMPL_RESOLVER_THREAD_POOL_IPP
|
|
#define ASIO_DETAIL_IMPL_RESOLVER_THREAD_POOL_IPP
|
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
|
# pragma once
|
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
|
|
|
#include "asio/detail/config.hpp"
|
|
#include "asio/config.hpp"
|
|
#include "asio/detail/memory.hpp"
|
|
#include "asio/detail/resolver_thread_pool.hpp"
|
|
#include "asio/error.hpp"
|
|
|
|
#include "asio/detail/push_options.hpp"
|
|
|
|
namespace asio {
|
|
namespace detail {
|
|
|
|
class resolver_thread_pool::work_scheduler_runner
|
|
{
|
|
public:
|
|
work_scheduler_runner(scheduler_impl& work_scheduler)
|
|
: work_scheduler_(work_scheduler)
|
|
{
|
|
}
|
|
|
|
void operator()()
|
|
{
|
|
asio::error_code ec;
|
|
work_scheduler_.run(ec);
|
|
}
|
|
|
|
private:
|
|
scheduler_impl& work_scheduler_;
|
|
};
|
|
|
|
resolver_thread_pool::resolver_thread_pool(execution_context& context)
|
|
: execution_context_service_base<resolver_thread_pool>(context),
|
|
scheduler_(asio::use_service<scheduler_impl>(context)),
|
|
work_scheduler_(scheduler_impl::internal(), context),
|
|
work_threads_(execution_context::allocator<void>(context)),
|
|
num_work_threads_(config(context).get("resolver", "threads", 0U)),
|
|
scheduler_locking_(config(context).get("scheduler", "locking", true)),
|
|
shutdown_(false)
|
|
{
|
|
work_scheduler_.work_started();
|
|
if (num_work_threads_ > 0)
|
|
start_work_threads();
|
|
else
|
|
num_work_threads_ = 1;
|
|
}
|
|
|
|
resolver_thread_pool::~resolver_thread_pool()
|
|
{
|
|
shutdown();
|
|
}
|
|
|
|
void resolver_thread_pool::shutdown()
|
|
{
|
|
if (!shutdown_)
|
|
{
|
|
work_scheduler_.work_finished();
|
|
work_scheduler_.stop();
|
|
work_threads_.join();
|
|
work_scheduler_.shutdown();
|
|
shutdown_ = true;
|
|
}
|
|
}
|
|
|
|
void resolver_thread_pool::notify_fork(execution_context::fork_event fork_ev)
|
|
{
|
|
if (!work_threads_.empty())
|
|
{
|
|
if (fork_ev == execution_context::fork_prepare)
|
|
{
|
|
work_scheduler_.stop();
|
|
work_threads_.join();
|
|
}
|
|
}
|
|
else if (fork_ev != execution_context::fork_prepare)
|
|
{
|
|
work_scheduler_.restart();
|
|
}
|
|
}
|
|
|
|
void resolver_thread_pool::start_resolve_op(resolve_op* op)
|
|
{
|
|
if (scheduler_locking_)
|
|
{
|
|
start_work_threads();
|
|
scheduler_.work_started();
|
|
work_scheduler_.post_immediate_completion(op, false);
|
|
}
|
|
else
|
|
{
|
|
op->ec_ = asio::error::operation_not_supported;
|
|
scheduler_.post_immediate_completion(op, false);
|
|
}
|
|
}
|
|
|
|
void resolver_thread_pool::start_work_threads()
|
|
{
|
|
asio::detail::mutex::scoped_lock lock(mutex_);
|
|
if (work_threads_.empty())
|
|
for (unsigned int i = 0; i < num_work_threads_; ++i)
|
|
work_threads_.create_thread(work_scheduler_runner(work_scheduler_));
|
|
}
|
|
|
|
} // namespace detail
|
|
} // namespace asio
|
|
|
|
#include "asio/detail/pop_options.hpp"
|
|
|
|
#endif // ASIO_DETAIL_IMPL_RESOLVER_THREAD_POOL_IPP
|