C - 如何同时使用 aio_read() 和 aio_write()

Question

我实现了需要读写的游戏服务器。因此，我接受传入连接并开始使用 aio_read() 读取连接，但是当我需要发送某些内容时，我停止使用 aio_cancel() 读取，然后使用 aio_write ()。在 write 的回调中我继续阅读。所以，我确实一直在阅读，但当我需要发送一些东西时 - 我暂停阅读。

它的工作时间约为 20% - 在其他情况下，对 aio_cancel() 的调用失败，并显示“操作正在进行中” - 并且我无法取消它（即使在永久 while 内）循环）。所以，我添加的写操作永远不会发生。

如何用好这些功能呢？我错过了什么？

编辑： 在Linux 2.6.35下使用。 Ubuntu 10 - 32 位。

示例代码：

void handle_read(union sigval sigev_value) { /* handle data or disconnection */ }
void handle_write(union sigval sigev_value) { /* free writing buffer memory */ }
void start()
{
    const int acceptorSocket = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in addr;
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port);
    bind(acceptorSocket, (struct sockaddr*)&addr, sizeof(struct sockaddr_in));

    listen(acceptorSocket, SOMAXCONN);

    struct sockaddr_in address;
socklen_t addressLen = sizeof(struct sockaddr_in);

    for(;;)
    {
         const int incomingSocket = accept(acceptorSocket, (struct sockaddr*)&address, &addressLen);
         if(incomingSocket == -1)
         { /* handle error ... */}
         else
         {
              //say socket to append outcoming messages at writing:
              const int currentFlags = fcntl(incomingSocket, F_GETFL, 0);
              if(currentFlags < 0) { /* handle error ... */ }
              if(fcntl(incomingSocket, F_SETFL, currentFlags | O_APPEND) == -1) { /* handle another error ... */ }

              //start reading:
              struct aiocb* readingAiocb = new struct aiocb;
              memset(readingAiocb, 0, sizeof(struct aiocb));
              readingAiocb->aio_nbytes = MY_SOME_BUFFER_SIZE;
              readingAiocb->aio_fildes = socketDesc;
              readingAiocb->aio_buf = mySomeReadBuffer;
              readingAiocb->aio_sigevent.sigev_notify = SIGEV_THREAD;
              readingAiocb->aio_sigevent.sigev_value.sival_ptr = (void*)mySomeData;
              readingAiocb->aio_sigevent.sigev_notify_function = handle_read;
              if(aio_read(readingAiocb) != 0) { /* handle error ... */ }
          }
    }
}

//called at any time from server side:
send(void* data, const size_t dataLength)
{
    //... some thread-safety precautions not needed here ...

    const int cancellingResult = aio_cancel(socketDesc, readingAiocb);
    if(cancellingResult != AIO_CANCELED)
    {
        //this one happens ~80% of the time - embracing previous call to permanent while cycle does not help:
        if(cancellingResult == AIO_NOTCANCELED)
        {
            puts(strerror(aio_return(readingAiocb))); // "Operation now in progress"
            /* don't know what to do... */
        }
    }
    //otherwise it's okay to send:
    else
    {
        aio_write(...);
    }
}

Answer 1

如果您希望有单独的 AIO 队列用于读取和写入，以便稍后发出的写入可以在较早发出的读取之前执行，那么您可以使用 dup() 创建套接字的副本，并且使用一个发出读取，另一个发出写入。

不过，我赞同完全避免 AIO 并简单地使用带有非阻塞套接字的 epoll() 驱动的事件循环的建议。这种技术已被证明可以扩展到大量客户端 - 如果您的 CPU 使用率很高，请分析它并找出发生这种情况的位置，因为很可能不是您的事件循环才是罪魁祸首。

Answer 2

首先，考虑抛弃 aio。还有很多其他方法可以实现异步 I/O，但它们并不那么脑残（是的，aio 就是脑残）。多种选择；如果您使用的是 Linux，则可以使用 libaio ( io_submit 和朋友）。 aio(7) 提到了这一点。

回到你的问题。
我已经很长时间没有使用 aio 了，但这是我记得的。 aio_read 和 aio_write 都将请求 (aiocb) 放入某个队列中。即使请求会在一段时间后完成，它们也会立即返回。完全有可能对多个请求进行排队，而不关心前面的请求发生了什么。因此，简而言之：停止取消读取请求并继续添加它们。

/* populate read_aiocb */
rc = aio_read(&read_aiocb);

/* time passes ... */
/* populate write_aiocb */
rc = aio_write(&write_aiocb)

稍后您可以使用 aio_suspend 等待，使用 aio_error 进行轮询，等待信号等。

我看到您在评论中提到了 epoll 。 你绝对应该选择libaio。

Answer 3

除非我没记错，否则 POSIX AIO（即 aio_read()、aio_write() 等）保证仅在可查找文件描述符上工作。来自 aio_read() 联机帮助页：

 从绝对文件偏移量 aiocbp->aio_offset 开始读取数据，无论
   当前文件位置。在此请求之后，当前文件位置的值是不确定的
   领域。

对于没有关联文件位置的设备（例如网络套接字、AFAICS、POSIX AIO）未定义。也许它恰好适用于您当前的设置，但这似乎更多是出于偶然，而不是设计。

此外，在 Linux 上，POSIX AIO 是在用户空间线程的帮助下在 glibc 中实现的。

也就是说，尽可能使用非阻塞 IO 和 epoll()。然而，epoll() 不适用于可查找的文件描述符，例如常规文件（对于经典的 select()/poll() 也是如此）；在这种情况下，POSIX AIO 是滚动您自己的线程池的替代方案。

Answer 4

没有理由仅仅因为需要进行另一次读取或写入而停止或取消 aio 读取或写入请求。如果是这样的话，那将破坏异步读写的全部意义，因为它的主要目的是允许您设置读取或写入操作，然后继续。由于可以对多个请求进行排队，因此最好设置几个异步读取器/写入器池，您可以从“可用”池中获取一组预先初始化的aiocb结构。在需要时设置异步操作，然后在完成后将它们返回到另一个“已完成”池，并且您可以访问它们指向的缓冲区。当它们处于异步读取或写入过程中时，它们将处于“繁忙”池中并且不会被触及。这样，每次需要进行读取或写入操作时，您就不必在堆上动态创建 aiocb 结构，尽管这样做没问题……只是效率不高，如果您永远不会计划超过一定的限制，或者计划只处理一定数量的“进行中”请求。

顺便说一句，请记住，有几个不同的正在进行的异步请求，您的异步读/写处理程序实际上可能会被另一个读/写事件中断。所以你真的不想和你的处理者一起做很多事情。在我描述的上述场景中，您的处理程序基本上会将触发信号处理程序的 aiocb 结构从一个池移动到列出的“可用”->“忙”-> 中的下一个池。 “完成”阶段。从“完成”池中的 aiocb 结构指向的缓冲区读取数据后，您的主代码会将结构移回“可用”池。