C++ Linux `io_uring`：异步 I/O 接口的极致性能与 C++ 封装

哈喽，各位好！

今天咱们来聊聊 C++ 在 Linux 下面玩转 io_uring 的那些事儿。说白了，就是怎么用 C++ 把这货封装起来，榨干它的性能，让你的程序跑得飞起。

io_uring 是 Linux 内核提供的一个异步 I/O 接口，它承诺能带来极致的性能。但直接用 C 接口嘛，有点原始，不够优雅，也不够 C++。所以，咱要给它穿上 C++ 的外衣，让它更易用、更安全、更高效。

1. 为什么选择 io_uring？

首先，咱得知道 io_uring 这玩意儿到底牛在哪儿？简单来说，它解决了传统异步 I/O (比如 epoll) 的一些痛点。

减少系统调用次数： 传统的异步 I/O 往往需要多次系统调用，比如提交请求、等待结果。io_uring 通过共享的 ring buffer，将提交和完成解耦，大大减少了系统调用次数。想想你排队买饭，以前是排一次队点菜，再排一次队取餐，现在是点完菜直接等着叫号，效率能不高吗？
零拷贝 (Zero-Copy) 支持： io_uring 可以直接在用户空间和内核空间之间传输数据，避免了不必要的数据拷贝。这就像你直接把文件从一个硬盘拖到另一个硬盘，而不用先复制到内存里再粘贴过去。
更灵活的操作： 除了读写，io_uring 还支持很多其他的操作，比如文件同步、文件操作等等。

2. io_uring 的基本概念

理解 io_uring 的核心在于理解它的两个 ring buffer：

Submission Queue (SQ)： 提交队列，用户程序把 I/O 请求放到这里。
Completion Queue (CQ)： 完成队列，内核把 I/O 操作的结果放到这里。

用户程序通过将 io_uring_sqe (submission queue entry) 放入 SQ，然后调用 io_uring_submit 提交请求。内核处理完请求后，将 io_uring_cqe (completion queue entry) 放入 CQ，用户程序再从 CQ 中读取结果。

可以把 SQ 想象成一个邮筒，你把信（I/O 请求）投进去，CQ 就像你的邮箱，邮递员（内核）把信（I/O 结果）放到里面。

3. C++ 封装的设计思路

我们的 C++ 封装的目标是：

易用性： 提供简洁的接口，让用户可以方便地提交 I/O 请求和处理结果。
安全性： 避免用户直接操作原始的 ring buffer，提供类型安全和内存安全。
高效性： 尽可能减少额外的开销，充分利用 io_uring 的性能。

一个简单的设计思路是：

IoUring 类： 封装 io_uring 的初始化、提交、等待等操作。
IoRequest 类： 封装 I/O 请求的相关信息，比如文件描述符、缓冲区、偏移量等。
IoResult 类： 封装 I/O 操作的结果，比如返回值、错误码等。

4. C++ 代码示例

下面是一个简化的 C++ 封装示例，展示了如何初始化 io_uring，提交一个读请求，并处理结果。

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <liburing.h>
#include <stdexcept>

class IoUring {
public:
    IoUring(unsigned entries) {
        if (io_uring_queue_init(entries, &ring_, 0) < 0) {
            throw std::runtime_error("Failed to initialize io_uring");
        }
    }

    ~IoUring() {
        io_uring_queue_exit(&ring_);
    }

    // 提交读请求
    int submitReadRequest(int fd, void* buf, size_t len, off_t offset) {
        io_uring_sqe* sqe = io_uring_get_sqe(&ring_);
        if (!sqe) {
            return -1; // SQ is full
        }

        io_uring_prep_read(sqe, fd, buf, len, offset);
        // 可以把用户数据绑定到 sqe 上，方便后续处理
        io_uring_sqe_set_data(sqe, buf);

        return io_uring_submit(&ring_);
    }

    // 等待完成事件
    int waitForCompletion() {
        io_uring_cqe* cqe;
        int ret = io_uring_wait_cqe(&ring_, &cqe);
        if (ret < 0) {
            return ret;
        }

        // 处理完成事件
        processCompletion(cqe);
        io_uring_cqe_seen(&ring_, cqe); // 通知内核已经处理了该事件

        return 0;
    }

private:
    void processCompletion(io_uring_cqe* cqe) {
        // 在这里处理 I/O 操作的结果
        void* user_data = io_uring_cqe_get_data(cqe);
        int res = cqe->res;

        if (res < 0) {
            std::cerr << "Error: " << strerror(-res) << std::endl;
        } else {
            std::cout << "Read " << res << " bytes" << std::endl;
        }
    }

    io_uring ring_;
};

int main() {
    try {
        IoUring ring(1024); // 初始化 io_uring，指定队列大小

        int fd = open("test.txt", O_RDONLY);
        if (fd < 0) {
            throw std::runtime_error("Failed to open file");
        }

        char buffer[4096];
        //提交读取文件的请求
        int ret = ring.submitReadRequest(fd, buffer, sizeof(buffer), 0);
        if (ret < 0) {
            std::cerr << "Failed to submit read request" << std::endl;
        }

        // 等待 I/O 完成
        ring.waitForCompletion();

        close(fd);

    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

代码解释：

IoUring 类封装了 io_uring 的初始化、提交和等待操作。
submitReadRequest 函数用于提交一个读请求。它首先从 SQ 中获取一个空闲的 io_uring_sqe，然后使用 io_uring_prep_read 函数填充该 SQE。最后，调用 io_uring_submit 提交请求。
waitForCompletion 函数用于等待 I/O 操作完成。它调用 io_uring_wait_cqe 函数等待 CQ 中出现完成事件。然后，它调用 processCompletion 函数处理完成事件。
processCompletion 函数从 CQE 中获取 I/O 操作的结果，并进行处理。

5. 进阶技巧

光有基本封装还不够，咱还得掌握一些进阶技巧，才能真正发挥 io_uring 的威力。

*使用 `io_uringprep函数：**liburing提供了很多io_uringprep*函数，用于方便地填充 SQE。比如io_uring_prep_read,io_uring_prep_write,io_uring_prep_fsync` 等等。
绑定用户数据： 可以使用 io_uring_sqe_set_data 函数将用户数据绑定到 SQE 上。这样，在处理完成事件时，就可以方便地获取这些数据。这就像给每个包裹贴上标签，方便你识别。
使用 fixed buffers： 可以预先注册一些 fixed buffers，避免每次 I/O 操作都分配和释放内存。这就像你事先准备好一些盘子，不用每次吃饭都去买新盘子。
使用 poll 模式： 可以使用 IORING_SETUP_IOPOLL 标志来启用 poll 模式，让内核在用户空间直接轮询设备，减少中断开销。但这会消耗更多的 CPU 资源，需要根据实际情况进行权衡。

6. 性能优化

io_uring 本身就以性能著称，但用 C++ 封装时，也要注意避免引入额外的性能瓶颈。

避免不必要的拷贝： 尽量使用零拷贝技术，避免在用户空间和内核空间之间拷贝数据。
减少内存分配： 尽量使用内存池或者预分配内存，避免频繁的内存分配和释放。
批量提交： 可以一次性提交多个 I/O 请求，减少系统调用次数。
合理设置队列大小： SQ 和 CQ 的大小会影响性能，需要根据实际情况进行调整。

7. 错误处理

错误处理是任何程序的重要组成部分，在使用 io_uring 时也不例外。

检查返回值： 务必检查 io_uring_submit 和 io_uring_wait_cqe 等函数的返回值，判断是否出现错误。
处理错误码： 从 CQE 中获取错误码，并进行相应的处理。
优雅地关闭 io_uring： 在程序退出前，务必正确地关闭 io_uring，释放资源。

8. 总结

io_uring 是一个强大的异步 I/O 接口，可以显著提高程序的性能。通过 C++ 封装，我们可以让它更易用、更安全、更高效。但是，io_uring 的使用也比较复杂，需要仔细理解其工作原理，并掌握一些进阶技巧。

下面是一个表格，总结了 io_uring 的一些关键概念和技巧：

特性/概念	描述	示例
Submission Queue (SQ)	用户程序提交 I/O 请求的队列	使用 `io_uring_get_sqe` 获取 SQE，使用 `io_uring_prep_*` 函数填充 SQE
Completion Queue (CQ)	内核返回 I/O 操作结果的队列	使用 `io_uring_wait_cqe` 等待 CQE，从 CQE 中获取结果
零拷贝	避免用户空间和内核空间之间的数据拷贝	使用 fixed buffers，或者利用 `splice` 等系统调用
Fixed Buffers	预先注册的缓冲区，避免每次 I/O 操作都分配和释放内存	使用 `io_uring_register_buffers` 注册缓冲区，然后在 SQE 中指定 buffer id
Poll 模式	内核在用户空间直接轮询设备，减少中断开销	在 `io_uring_queue_init` 中使用 `IORING_SETUP_IOPOLL` 标志
用户数据绑定	将用户数据绑定到 SQE 上，方便后续处理	使用 `io_uring_sqe_set_data` 函数
批量提交	一次性提交多个 I/O 请求，减少系统调用次数	循环调用 `io_uring_get_sqe` 和 `io_uring_prep_*`，然后一次性调用 `io_uring_submit`
错误处理	检查返回值，处理错误码，优雅地关闭 `io_uring`	检查 `io_uring_submit` 和 `io_uring_wait_cqe` 的返回值，从 CQE 中获取错误码，在程序退出前调用 `io_uring_queue_exit`

希望今天的分享能帮助大家更好地理解和使用 io_uring。记住，实践是检验真理的唯一标准，多写代码，多尝试，你就能掌握 io_uring 的精髓！

最后，祝大家编程愉快，Bug 越来越少，程序跑得越来越快！

发表回复 取消回复

发表回复取消回复