以嵌套或递归方式（即在处理程序内）调用 asio io_service poll() 或 poll_one() 是否有效？

Question

以嵌套或递归方式（即从处理程序内）调用 asio::io_service::poll() 或 poll_one() 是否有效？

一个非常基本的测试似乎暗示这有效（我只在一个平台上完成了测试）但我想确保从处理程序中再次调用 poll() 被认为是有效的行为。

我在 asio 文档中找不到任何相关信息，所以我希望对 asio 内部工作有更多经验的人可以通过解释或参考来验证这一点。

基本测试：

struct NestedHandler
{
    NestedHandler(std::string name, asio::io_service * service) :
        name(name),
        service(service)
    {
        // empty
    }

    void operator()()
    {
        std::cout << " { ";
        std::cout << name;

        std::cout << " ...calling poll again... ";
        service->poll();
        std::cout << " } ";

    }

    std::string name;
    asio::io_service * service;
};

struct DefaultHandler
{
    DefaultHandler(std::string name) :
        name(name)
    {
        // empty
    }

    void operator()()
    {
        std::cout << " { ";
        std::cout << name;
        std::cout << " } ";
    }

    std::string name;
};

int main()
{
    asio::io_service service;
    service.post(NestedHandler("N",&service));
    service.post(DefaultHandler("A"));
    service.post(DefaultHandler("B"));
    service.post(DefaultHandler("C"));
    service.post(DefaultHandler("D"));

    std::cout << "asio poll" << std::endl;
    service.poll();

    return 0;
}

// Output:
asio poll
 { N ...calling poll again...  { A }  { B }  { C }  { D }  }

Answer 1

Is calling asio::io_service::poll() or poll_one() in a nested or recursive fashion (ie. from within a handler) valid?

从语法上讲，这是有效的。但是，它不是很好，因为在每个处理程序中你都应该运行 poll()。此外，您的堆栈跟踪将增长到非常大的大小，您可能会遇到堆栈的大问题。

Answer 2

有效。

对于处理 io_service 的函数族，run() 是唯一有限制的：

The run() function must not be called from a thread that is currently calling one of run(), run_one(), poll() or poll_one() on the same io_service object.

但是，我倾向于认为文档也应该包含对 run_one() 的相同注释，因为嵌套调用可能导致它在以下任一情况下无限期阻塞^{[ 1]}:

io_service 中唯一的工作是当前正在执行的处理程序
对于非 I/O 完成端口实现，唯一的工作是从当前处理程序中发布的，io_service 具有 1

对于 Windows I/O 完成端口，在使用 GetQueuedCompletionStatus(). At a high-level, threads calling GetQueuedCompletionStatus() function as if they are part of a thread pool, allowing the OS to dispatch work to each thread. As no single thread is responsible for demultiplexing operations to other threads, nested calls to poll() or poll_one() do not affect operation dispatching for other threads. The documentation 状态服务于 io_service 的所有线程中执行多路分解：

Demultiplexing using I/O completion ports is performed in all threads that call io_service::run(), io_service::run_one(), io_service::poll() or io_service::poll_one().

对于所有其他多路分解机制系统，单线程服务 io_service 用于多路分解 I/O 操作。确切的多路分解机制可以在 Platform-Specific Implementation Notes:

中找到

Demultiplexing using [/dev/poll, epoll, kqueue, select] is performed in one of the threads that calls io_service::run(), io_service::run_one(), io_service::poll() or io_service::poll_one().

多路分解机制的实现略有不同，但总体上有所不同：

io_service 有一个主队列，线程从中消耗准备运行操作来执行
每次调用处理 io_service 都会在堆栈上创建一个私有队列，用于以无锁方式管理操作
最终会与主队列同步，获取锁并将私有队列操作复制到主队列，通知其他线程，并允许它们从主队列消费。

当 io_service 为 constructed 时，可能会提供 并发提示 ，建议实施应允许多少线程运行同时。当非 I/O 完成端口实现提供 1 的并发提示时，它们被优化为尽可能多地使用私有队列并延迟与主队列的同步。例如，当处理程序通过 post():

发布时

如果从处理程序外部调用，则 io_service 保证线程安全，因此它会在处理程序入队之前锁定主队列。
如果从处理程序中调用，发布的处理程序将排入专用队列，延迟与主队列的同步，直到必要时。

当调用嵌套的poll()或poll_one()时，有必要将私有队列复制到主队列中，因为要执行的操作将从主队列中消耗。这种情况在 implementation:

中明确检查

// We want to support nested calls to poll() and poll_one(), so any handlers
// that are already on a thread-private queue need to be put on to the main
// queue now.
if (one_thread_)
  if (thread_info* outer_thread_info = ctx.next_by_key())
    op_queue_.push(outer_thread_info->private_op_queue);

当没有并发提示或提供 1 以外的任何值时，发布的处理程序每次都会同步到主队列中。由于不需要复制私有队列，嵌套的poll()和poll_one()调用将正常运行。

^{1.在 networking-ts draft 中，注意不能从当前正在调用 run().}

的线程调用 run_one()

以嵌套或递归方式（即在处理程序内）调用 asio io_service poll() 或 poll_one() 是否有效？

Is calling asio io_service poll() or poll_one() in a nested or recursive fashion (ie. within a handler) valid?

c++

boost-asio