从 epoll 到 io_uring:等待的成本,和一次语义错位

TL;DR

上一篇拆完 async fn 的状态机,留了两个坑:epoll 在高并发下到底卡在哪,io_uring 会不会把 reactor 干掉。

这篇一起补。答案分别是:

  • epoll 不卡在 epoll_wait 里,卡在它前后那两段路上;
  • reactor 不会被干掉,但 io_uring 会把它换个形状。
阻塞 read:一万条连接 = 一万个睡着的线程
  → select/poll:一次等一批,但每次都得把整个集合重报一遍
    → epoll:注册一次,内核记住,只报就绪的
      → 可它只说「现在读不会阻塞」,数据还得你自己搬
        → Linux AIO 想连搬也代劳,可惜只对 O_DIRECT 有效
          → io_uring:提交队列 + 完成队列,内核连搬带通知
            → reactor 没消失,只是从「通知就绪」改成「通知完成」

真正的麻烦藏在最后一步。io_uring 给的是完成(completion)语义,而 Rust 的 Future 是照着就绪(readiness)语义长的。这两个词差一个字,落到 API 上就是 &mut [u8] 和「缓冲区的所有权必须交出去」的区别。


等待只有三个变量

把「等」这个动作拆开,其实就三个问题:谁停下来、谁去叫醒、醒了之后谁搬东西。

接口谁停谁叫谁搬
阻塞 read线程内核(wake_up 唤醒队列)线程自己,在 read 里面
select/poll线程内核线程自己,再 read 一次
epoll线程(epoll_wait 里)内核回调线程自己,再 read 一次
io_uring线程(可以不等)内核写 CQE内核

前三代有个共同点:内核只负责说「可以了」,read() 还是你自己发起的。

这不是偷懒。read(fd, buf, n) 的 buf 是用户态地址,内核只有在你调用的那一瞬间才知道它是谁。等你想让内核「顺手把数据也搬了」,就必须提前把地址告诉它。

io_uring 干的就是这件事,别的都是配套。


阻塞读:一个连接,一个睡着的线程

ssize_t n = read(fd, buf, len);

数据没到,内核大概这么走:

  1. 把线程挂到这个 fd 的 wait_queue_head_t 上;
  2. 状态改成 TASK_INTERRUPTIBLE,调 schedule() 让出 CPU;
  3. 调度器挑下一个活干;
  4. 数据到了,网卡中断 → 软中断 → 协议栈 → wake_up(),线程回到 TASK_RUNNING;
  5. 线程被重新调度,从 schedule() 返回,复查条件,拷贝。

上一篇量过,两个线程 ping-pong 一次大概 1960ns。钱就花在这条路上:挂起一次内核陷进去,唤醒一次再陷进去,中间还过一遍调度器。

一万条连接就是一万份这个结构。所以真正的代价从来不是切换慢,是每一份等待都占着一个完整的调度实体和一块栈。为了等一个几百字节的包,先把 8MB 虚拟地址空间占了。


select 和 poll:能等一批,但每次都要重报

fd_set rfds;
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
select(maxfd + 1, &rfds, NULL, NULL, NULL);

三个老毛病:

  • fd_set 是位图,大小被 FD_SETSIZE 钉死在 1024。fd 号超了就没地方放。
  • 每次调用都得把整个位图拷进内核,回来再拷一遍。一万个 fd 是每次 1250 字节的来回,跟你实际有几个就绪毫无关系。
  • 内核里没地方存「谁在等」,每次都从头扫。

poll 把位图换成数组,1024 的上限没了,另外两条原封不动。每次全量重传,每次内核全扫。

O(n) 里的 n 是注册总数,不是就绪数。一万个连接里三个活跃,照样扫一万次。

这背后的根子在于:select/poll 把「注册」和「等待」压进了同一个系统调用。只要这两件事捆在一起,就必然每次重报。想省掉,就得把注册拆出去,让内核常驻一份。


epoll:把等待搬进内核

int ep = epoll_create1(0);

struct epoll_event ev = { .events = EPOLLIN, .data.fd = fd };
epoll_ctl(ep, EPOLL_CTL_ADD, fd, &ev);        // 注册一次,长期有效

struct epoll_event evs[64];
int n = epoll_wait(ep, evs, 64, -1);          // 只返回就绪的

里面就两样东西

一棵红黑树,存所有注册过的 fd,epoll_ctl 增删改查 O(log n)。

一个就绪链表,存已经好了、还没被取走的。

注册的时候,内核顺手在这个 fd 的等待队列上挂一个 ep_poll_callback。fd 一旦就绪,回调被触发,把节点塞进就绪链表。于是 epoll_wait 只干两件事:链表非空就取一批,空了就自己睡。

复杂度 O(就绪数),跟总连接数脱钩。一万个连接三个活跃,它就只处理三个。

这一段经常被当成 epoll 的全部,然后得出「epoll 是 O(1)」的结论。不全对。

钱花在哪

上一篇那个问题,答案不在返回值里。

网卡中断(CPU 0)
  → 软中断 → 协议栈 → 数据进 socket 接收队列
  → ep_poll_callback():拿 ep->lock,把节点挂进 rdllist
  → wake_up() 叫醒 epoll 的等待者(可能得发 IPI 到另一个核)

worker(CPU 3)
  → 从 epoll_wait 出来,把就绪事件拷到用户态
  → 遍历事件:fd → runtime 里登记的对象 → 掏出 waker
  → waker.wake():把任务塞进某个 worker 的本地队列
  → 任务被调度,poll 一次,Ready,再 read() 把数据拷进来

中断在 CPU 0,处理在 CPU 3。中间至少两次缓存行改主:rdllist 的 head/tail 一次,任务的队列节点一次。这些一个都不在 epoll_wait 的返回值里,但都是真金白银。

还有一层更隐蔽的。rdllist 和 ep->lock 是每个 epoll 实例一份。多线程共用一个实例,所有 worker 抢同一把锁;每个 worker 各来一个,同一个 fd 又只能注册在其中一家,负载一偏就是一边饿死一边闲着。SO_REUSEPORT 在这几年这么流行,跟这个是同一个病根。

就绪不是完成

这个区别决定了上层所有 API 的形状,值得单独说一句。

epoll 报的是「你现在调 read 不会阻塞」,不是「数据已经在你手里了」。

边界情况会露馅。「就绪」到你真正调 read,中间隔着一整个用户态,另一个线程完全可能先把数据叼走了。所以在 epoll 上做异步,read 必须能处理 EAGAIN。

epoll 默认水平触发,条件还在就会反复报,漏一次还有下一次,日子好过些。但语义上它始终是「就绪」,不是「完成」。这一点等到 io_uring 出场会变得很要命。

还剩两件事

epoll 把「通知」做到了极致,但有两样它管不着:

  1. 数据还得你自己搬。一次唤醒,后面跟一次 read 系统调用,再加一次内存拷贝。三件事一件都省不掉。
  2. 每次操作还得一次系统调用。一万个就绪,就是一万次 read。

io_uring:连「做」也交出去

它先干掉的是 Linux AIO

很多人以为 io_uring 是来替 epoll 的。其实它第一个动手的对象是 Linux AIO(io_submit / io_getevents)。

那东西有两个硬伤:

  • 只有 O_DIRECT 的块设备是真异步。走页缓存的文件,提交的时候直接同步阻塞,等于没异步。这也是上一篇说「tokio 的文件 IO 其实是阻塞线程池」的原因:io_uring 之前,Linux 上压根没有通用的异步文件 IO。
  • 提交一次系统调用,取完成又一次,批量能力约等于没有。

而且它跟 epoll 一样,是就绪思路的延长线,没碰「谁搬数据」。

两个环

io_uring 对外只有三个系统调用。核心想法土得掉渣:拿一块共享内存当队列,用户态和内核态互相传纸条,系统调用就省了。

        用户态                        内核态
   ┌──────────────┐            ┌──────────────┐
   │  SQ: tail ───┼─── 写入 SQE ─→│             │
   │  SQ: head ←──┼────────────┼── 消费       │
   ├──────────────┤            ├──────────────┤
   │  CQ: tail ←──┼────────────┼── 写入 CQE   │
   │  CQ: head ───┼─── 读取 CQE ─→│             │
   └──────────────┘            └──────────────┘
        (两个环在同一段 mmap 里,SINGLE_MMAP)
  • SQ:你往里填「要做什么」。一条 SQE 64 字节。
  • CQ:内核往里写「做完了,结果这样」。一条 CQE 16 字节。
  • 两边各自维护 head/tail,靠内存序同步,不上锁(单生产者单消费者)。

关键是:填 SQE 不是系统调用,只是往共享内存写 64 字节。

进内核的时机只有一个:把 tail 推出去、告诉内核有活干。这一次 io_uring_enter 能一口气干三件事:

  • 提交一批(to_submit);
  • 顺带等一批完成(min_complete 加 IORING_ENTER_GETEVENTS);
  • 或者纯提交,不等。

开了 IORING_SETUP_SQPOLL 更省,内核起个线程盯着 tail,连这一下 enter 都免了。代价是常驻一个核。

手搓一遍

不碰 liburing,直接对着 linux/io_uring.h 写,才知道那层封装到底在遮什么。

系统调用入口就两行:

#include <linux/io_uring.h>
#include <sys/syscall.h>
#include <sys/mman.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

static int io_uring_setup(unsigned entries, struct io_uring_params *p) {
    return syscall(__NR_io_uring_setup, entries, p);
}

static int io_uring_enter(int fd, unsigned submit, unsigned wait, unsigned flags) {
    return syscall(__NR_io_uring_enter, fd, submit, wait, flags, NULL, 0);
}

初始化最多三次 mmap,换回八个指针:

struct ring {
    unsigned *sq_head, *sq_tail, *sq_mask, *sq_array;
    unsigned sq_entries;
    unsigned pending;          /* 已填写、尚未通知内核的 SQE 数 */
    struct io_uring_sqe *sqes;
    unsigned *cq_head, *cq_tail, *cq_mask;
    struct io_uring_cqe *cqes;
    int fd;
};

static void ring_init(struct ring *r, unsigned entries) {
    struct io_uring_params p;
    memset(&p, 0, sizeof(p));
    r->fd = io_uring_setup(entries, &p);
    if (r->fd < 0) { perror("io_uring_setup"); exit(1); }
    r->sq_entries = p.sq_entries;
    r->pending = 0;

    /* 环里承载 SQE / CQE 的区域,外加 array 映射表 */
    size_t sq_sz = p.sq_off.array + p.sq_entries * sizeof(unsigned);
    size_t cq_sz = p.cq_off.cqes + p.cq_entries * sizeof(struct io_uring_cqe);

    /* SINGLE_MMAP:SQ 环和 CQ 环在同一块物理页,映射一次就够 */
    size_t sz = sq_sz > cq_sz ? sq_sz : cq_sz;
    char *sq = mmap(NULL, sz, PROT_READ | PROT_WRITE,
                    MAP_SHARED | MAP_POPULATE, r->fd, IORING_OFF_SQ_RING);
    char *cq = (p.features & IORING_FEAT_SINGLE_MMAP)
             ? sq
             : mmap(NULL, cq_sz, PROT_READ | PROT_WRITE,
                    MAP_SHARED | MAP_POPULATE, r->fd, IORING_OFF_CQ_RING);

    /* SQE 是定长 64 字节的连续数组,单独映射 */
    r->sqes = mmap(NULL, p.sq_entries * sizeof(struct io_uring_sqe),
                   PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
                   r->fd, IORING_OFF_SQES);

    /* 偏移量由内核给,写死会随版本炸 */
    r->sq_head  = (unsigned *)(sq + p.sq_off.head);
    r->sq_tail  = (unsigned *)(sq + p.sq_off.tail);
    r->sq_mask  = (unsigned *)(sq + p.sq_off.ring_mask);
    r->sq_array = (unsigned *)(sq + p.sq_off.array);

    r->cq_head = (unsigned *)(cq + p.cq_off.head);
    r->cq_tail = (unsigned *)(cq + p.cq_off.tail);
    r->cq_mask = (unsigned *)(cq + p.cq_off.ring_mask);
    r->cqes    = (struct io_uring_cqe *)(cq + p.cq_off.cqes);
}

ring_mask 的来历是个小约定:环大小向上取整到 2 的幂,于是 tail & mask 就是下标,不用取模。两个环宁可浪费一点空间,也要保住这个性质。

然后是填 SQE 和提交。这段我第一次写错了,值得展开。

static struct io_uring_sqe *get_sqe(struct ring *r) {
    unsigned tail = *r->sq_tail + r->pending;      /* 用户态自己记账 */
    if (tail - *r->sq_head >= r->sq_entries) return NULL;   /* 环满了 */
    unsigned idx = tail & *r->sq_mask;
    r->sq_array[idx] = idx;                 /* array 决定内核按什么顺序取 */
    r->pending++;
    return &r->sqes[idx];
}

static void submit_and_wait(struct ring *r, unsigned wait) {
    /* 全部填完,才把 tail 写回共享内存 */
    __atomic_store_n(r->sq_tail, *r->sq_tail + r->pending, __ATOMIC_RELEASE);
    io_uring_enter(r->fd, r->pending, wait, IORING_ENTER_GETEVENTS);
    r->pending = 0;
}

主流程:

int main(void) {
    struct ring r;
    ring_init(&r, 8);

    int fd = open("/etc/hostname", O_RDONLY);
    static char buf[256];

    /* 第一条:NOP,先把环跑通 */
    struct io_uring_sqe *sqe = get_sqe(&r);
    memset(sqe, 0, sizeof(*sqe));
    sqe->opcode    = IORING_OP_NOP;
    sqe->user_data = 1;

    /* 第二条:READ,buf 的地址直接交给内核 */
    sqe = get_sqe(&r);
    memset(sqe, 0, sizeof(*sqe));
    sqe->opcode    = IORING_OP_READ;
    sqe->fd        = fd;
    sqe->addr      = (unsigned long)buf;
    sqe->len       = sizeof(buf);
    sqe->off       = 0;
    sqe->user_data = 2;

    submit_and_wait(&r, 1);   /* 两条都交,但只等一条回来 */

    /* 收 CQE。完成顺序不保证跟提交顺序一致,靠 user_data 认领 */
    for (int got = 0; got < 2; got++) {
        while (*r.cq_head == *r.cq_tail) {          /* 完整实现还得处理等待 */
            io_uring_enter(r.fd, 0, 1, IORING_ENTER_GETEVENTS);
        }
        struct io_uring_cqe *cqe = &r.cqes[*r.cq_head & *r.cq_mask];
        printf("user_data=%llu res=%d\n",
               (unsigned long long)cqe->user_data, cqe->res);
        (*r.cq_head)++;                              /* 告诉内核:这条我取走了 */
    }
    return 0;
}

第一次跑,两条 READ

第一版里 get_sqe 是这么写的:直接读 *r->sq_tail 当下标,提交的时候才推进它。

跑出来是这样:

user_data=2 res=5
user_data=2 res=5

NOP 没了,两条 READ。盯着看一会儿就明白了:两次 get_sqe 之间 *r->sq_tail 一动没动,所以两次都返回 sqes[0]。第二条 memset 把第一条 NOP 整个盖掉,sq_array[0] 和 sq_array[1] 指向同一块内存。于是提交上去的是两条一模一样的 READ。

修法是加个 pending 计数,在用户态记账,提交时才把 tail 推出去。

这个坑不是笔误。sq_tail 一旦写进共享内存,就等于宣告「这一段归你了,拿去吧」。SQPOLL 模式下内核线程一直盯着它,你推早了,它就会去读一块还没填完的内存。liburing 在用户态缓存 head/tail,也是同一个理由。

几个绕不开的细节

  • user_data 是唯一身份证。64 位整数,内核原样带回来。Rust 那边通常塞 slab 下标或者 Arc<Task> 的裸指针,CQE 一到就靠它找到 waker。相当于 epoll 的 epoll_event.data。
  • 完成是乱序的。提交顺序 NOP、READ,回来不一定是这个顺序。所以 user_data 不是图方便,是必需品。
  • res 就是返回值,负数等于 -errno。这里没有 errno 这回事。
  • 共用一块 mmap 说明 SQ 和 CQ 生死一致。这个信号挺明显:提交和完成是一体两面,不像 epoll 的注册表和就绪链表那样可以拆开看。

内存账

512 项的环:

SQE  : 512 × 64B  = 32 KB
array: 512 ×  4B  =  2 KB
CQE  : 1024 × 16B = 16 KB     (CQ 默认是 SQ 的两倍,防完成丢失)
                   ─────────
                    50 KB      ≈ 每条在途请求 100 字节

上一篇把「每个并发单元」的成本从 8MB 压到几百字节。这里换个算法:每条在途 IO 大概 100 字节,里面没有栈,没有调度实体,也没有一个睡着的线程。

CQ 取两倍不是大方,是因为完成可能比提交跑得还快。CQ 满了还有 CQE 要写,内核只能置 overflow 标志先攒着,等你腾地方再补。这是一条必须处理的错误路径,别当它不存在。

后面讲 Rust 要用到,先记住两个。

link:给 SQE 打上 IOSQE_IO_LINK,内核串行执行,前一个失败后面全取消。read → write 这种「把 A 搬到 B」不用再回用户态两趟。

multishot:一条 IORING_OP_ACCEPT_MULTISHOT 或 RECV_MULTISHOT 能产生多条 CQE,直到你取消。

第二个有意思。它把就绪语义又塞回了完成接口里。 一次提交、反复完成,这不就是 epoll_ctl 注册一次、反复上报的路子,只不过现在连搬运都在内核里做完了。


回到 Rust

poll 的语义就是 readiness

Future::poll 只问一件事:现在好了没有。返回 Pending 的时候带一条契约:将来一定得有人调 waker。

「还没好」=「条件没满足」=「有资格了再来问我」。这就是 readiness,一个字都不差。

所以这也不是谁抄谁。Future 的抽象边界正好卡在「通知」这一步,压根没管数据谁搬——因为它出生在 epoll 的世界里。

三种后端摆在一起,接口形状差得很明显:

后端poll 说 Ready 是什么意思借用检查器看到什么
epoll现在 read 不会阻塞借用只在 poll 内部,可以 &mut [u8]
阻塞线程池真读完了同上,阻塞在别的线程
io_uring内核已经读完了buffer 在内核手里,碰不得

第三行就是所有麻烦的源头。

reactor 只换了事件源

epoll 后端:

任务 poll → 撞上 EAGAIN → 把 waker 登记到 fd 的槽位 → 返回 Pending
epoll_wait 回来 → fd 就绪 → 取出 waker → wake() → 任务回到队列
任务 poll → 这次 read 成功 → 返回 Ready

io_uring 后端:

任务 poll → 填一条 SQE(user_data = 任务 id)→ 返回 Pending
CQE 回来 → 按 user_data 找到 waker → wake()
任务 poll → 直接读 cqe->res → 返回 Ready

结构一模一样,只是事件源从「fd 就绪」换成了「CQE 到了」。

那最省事的接法就很明显:把 io_uring 的 fd 塞进现有的 epoll reactor。它的 fd 本身可 poll,CQ 里有货就变可读。

代价也很明显:省下来的那次 read,被一次 epoll_wait 换回去了。 绕一圈,还是在用 epoll 通知自己「有 CQE 了」。所以 tokio-uring 不这么干,它自己起一个线程阻塞在 io_uring_enter 上。

buffer 借不出去

真正的分水岭在两个签名上:

// tokio(readiness):借用
async fn read(&mut self, buf: &mut [u8]) -> io::Result<usize>;

// tokio-uring(completion):交出所有权
async fn read<T: IoBufMut>(&mut self, buf: T) -> BufResult<usize, T>;

tokio 敢借,因为它是就绪模型:poll 返回 Ready 的那一刻,数据早就被 read() 拷进 buffer 了,借用从来没跨过暂停点。

tokio-uring 必须拿走,因为 poll 返回 Pending 的时候,buf.as_mut_ptr() 已经在内核手上了。内核可以在你返回之后的任意时刻往那个地址写。 用户态这时候还能拿到 &mut [u8],就是 data race——还是内核参与的那种,编译器根本管不着。

Pin 在这里也跟着变了味道:

在 async fn 的状态机里,buffer 是结构体的一个字段,地址等于 future 地址加一个固定偏移。所以 Pin 住 future,等于把交给内核的那个指针也钉死了。

epoll 时代,Pin 主要防「自引用状态机被搬走」;到了 io_uring,它还多了一重职责:保证内核手里那根裸指针不会失效。同一个类型,干两份活。

取消更麻烦。就绪模型下,取消就是不再 poll,干净利落。完成模型下,你得发一条 IORING_OP_ASYNC_CANCEL,然后等它的结果——因为在取消发出去之前,那个操作可能已经做完了。CQE 没回来就释放 buffer,内核就往已释放的内存里写。

所以 Rust 里所有 io_uring 封装都有这几个特征:Drop 里带 grace period,返回 BufResult,死活不给 &mut [u8]。不是他们代码写得丑,是完成语义逼的。

内核吃掉了一部分 executor

把前面两个特性拎出来看:

  • link 把「两个 await」压成「一条 SQE 链」,状态机少一个变体,少一次唤醒;
  • multishot 把「epoll_ctl 注册 + 反复 wake」这一套整个搬进内核。

内核确实在抢 reactor 和 executor 的活。Future 也没被架空,只是理由换了。

有,但理由变了。内核交付的粒度是「一批操作做完了」,Future 表达的是一个任务活了一辈子:

  • 组合:select!、join!、timeout 都在类型层面拼,内核压根不知道哪个 future 属于哪个任务;
  • 取消:drop 即取消,这套语义只有用户态定得了,内核只认 SQE;
  • 调度:任务之间的公平性、队列、偷取,内核一概不管;
  • 抽象:同一份代码要能跑在 epoll 和 io_uring 上,中间就得有一层把「完成」糊成「就绪」的东西,那就是 reactor。

内核优化的是单次系统调用的往返,Future 优化的是逻辑任务的表达。层级都不一样,谈不上替代。


现实问题

写到这,io_uring 看着像个纯升级。但它有个绕不过去的坎:攻击面。

一个能在内核里长期攥着用户指针、文件引用,还允许你注册任意内存当 buffer 的接口,等于在内核里开了一整套新的生命周期管理。这些年出事的方向基本集中在几处:注册 buffer 和文件表的管理、SQE 链失败时的回滚、各个 opcode 的参数校验。

后果是三方面的:

  • 能不能用先打个问号。Google 在 Android 上对第三方 App 禁了 io_uring,ChromeOS 和自家生产环境也关着,理由说得很直白:提权漏洞里出现频率太高,收益盖不住风险。不少容器运行时和发行版在 seccomp 里直接把 io_uring_setup 拦了,云厂商也可能在宿主机上关掉。你写好的代码,到别人机器上可能直接 EPERM。
  • 出问题不好查。strace 只能看见一次 io_uring_enter,具体提交了啥全在共享内存里,不进内核就看不见。既没有 read 那样的调用栈,也没有 epoll 那样干净的 fd 语义。
  • 性能不是白给的。小 IO 场景,填 SQE 加收 CQE 未必比一次 read 便宜。SQPOLL 要占一个核,IOPOLL 只对块设备有意义。网络路径上的大头通常是协议栈和内存拷贝,不是系统调用次数,批处理红利得在高 IOPS 下才吃得到。

所以它的位置很清楚:不是通用替代品,是给特定负载准备的刀。


怎么选

场景选什么为什么
普通网络服务,连接数万级epoll(tokio)生态熟、能观测、不赌内核配置
极高 IOPS,大量小请求io_uring批量提交,能省掉逐次系统调用
真正的异步文件 IOio_uringLinux 上没别的路,其他都是线程池假扮的
要发给任意客户端epoll对面可能根本没有 io_uring 权限
延迟敏感,想自己管调度io_uring + 自研 executorSQPOLL 加绑核

几个常见坑:

  1. 以为 epoll 说可读就一定有数据。EAGAIN 必须处理,多线程共享 fd 时尤其如此。
  2. 用了边缘触发却不排空。ET 只在状态跳变时报一次,你不读到 EAGAIN,它永远不会再吭声。
  3. 以为 io_uring 的完成按提交顺序来。user_data 不是可选项。
  4. 取消完立刻释放 buffer。取消是异步的,CQE 可能在你释放之后才到。
  5. 给完成模型设计 &mut [u8] 接口。编译器会拦你,别硬绕。

最后

上一篇留的两个问题,现在能答了。

epoll 的瓶颈确实不在 epoll_wait 里。它在中断上下文那次 ep_poll_callback,在跨核的 rdllist 争用,在返回之后「fd → waker → 队列 → 调度」那一串分发。扫早就不成问题了,问题是你把一万个等待合进内核,回头还得一个一个拆出来。

io_uring 也不会让 reactor 变得多余,它只是把 reactor 换了个形状。epoll 的 reactor 把「就绪」翻译成唤醒,io_uring 的把「完成」翻译成唤醒。翻译层一直在,变的只是源头:从「可以了」变成「做完了」。

真正被改写的是 Rust 这边。borrow checker、Pin、Drop,这三个东西的含义都跟着「谁攥着 buffer」一起变了。接口从就绪换到完成,看着是内核的事,其实把 Rust 内存安全模型的边界重新画了一遍。

下一步想看看 IORING_REGISTER_PBUF_RING(预注册 buffer 环)和 zero-copy 收发。那条路才是真的把拷贝也省掉,但 buffer 生命周期的复杂度得上一个台阶。


参考资料

recent-work

bustub的多线程共享读锁设计

TL;DR 在做bustub 实验的Project 1时,在实现BufferPoolManager时,就需要开始接触C++-17的并发编程。 一开始最容易写出来的版本,是给整个BufferPoolManager配一把大锁。可以运行,但它把本不相关的操作也串成了一条队列。 所以这套 …

Read more →

axum 路由笔记:类型能管的和管不了的

TL;DR axum 的路由看起来是一张表,底下其实叠了三层类型。状态没给,编译不过;提取器顺序写反,编译不过;方法重复了,注册那一刻 panic;路径撞了,也 panic。哪些错误能提前、哪些必须等到启动,界线画得挺清楚,而且基本能从类型上推出来。 下面这些结论都是拿 …

Read more →