高性能异步IO机制：IO_URING

最新推荐文章于 2024-05-12 22:31:03 发布
最新推荐文章于 2024-05-12 22:31:03 发布
阅读量3.5k 收藏 28
点赞数 6
分类专栏： 文件系统 协议栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17045267/article/details/117953632
版权

高性能异步IO机制：IO_URING

一、前言

1.1 异步IO机制

Linux内核提供的IO机制大都是同步实现的，如常规的read/write/send/recv等系统调用。同步IO机制存在着一定的弊端，例如：（1）IO的实现都是在当前进程上下文的系统调用中完成的，会阻塞当前进程，降低系统的实时性；（2）性能较低。

异步IO指的是用户程序将IO请求提交后，无需等待IO操作的完成，而是可以继续处理别的事情。当IO操作完成后，会以某种方式通知用户程序。Linux系统下现有的异步IO机制的实现主要为两种：

  1. POSIX AIO。这种方案是用户态实现的异步IO机制，其核心思想为：创建一个专门用来处理IO的线程，用户程序将IO操作交给该线程来进行。这种方式实现的异步IO效率和扩展性都比较差。
  2. LINUX AIO。Linux内核里也实现了一套异步IO机制，被称为AIO。该机制的使用限制比较大，比如只支持direct IO而无法使用cache，且扩展性比较差。

在此背景下，Linux社区在5.1版本中引入了一种全新的异步IO机制：io_uring。io_uring提供了一套全新的系统调用接口，凭借着其高性能、高扩展性等优势脱颖而出，成为了目前Linux下主流的异步IO方案。

1.2 优势

相比于现有的异步IO机制，io_uring的优势主要体现在以下几方面：

  • 高效。一方面，io_uring采用了共享内存的方式来传递参数，减少了数据拷贝；另一方面，其采用ringBuf的方式来实现批量的IO请求，减少了系统调用的次数。
  • 可扩展性强。io_uring具有超强的可扩展性，具体表现在：（1）其支持的IO设备类型多样化，不仅支持块设备的IO，还支持任何基于文件的IO，例如套接口、字符设备等；（2）其支持的IO操作多样化，不仅支持常规的read/write，还支持send/recv/sendmsg/recvmsg/close/sync等大量的操作，而且能够很灵活地进行扩充。
  • 易用。io_uring提供了配套的liburing库，其对io_uring的系统调用进行了大量的封装，使得接口变得简单易用。
  • 可伸缩。io_uring提供了poll模式，对于IO性能要求较高的场景，允许用户牺牲一定的CPU来获得更高的IO性能：低延迟、高IOPS。

经测试，相比于libaio，在poll模式下io_uring性能提升将近150%，堪比SPDK。特别是在高QD的情况下，更是有赶超SPDK的趋势。

二、io_uring整体框架

io_uring的整体框架如下图所示，用户态程序在开发时只需要调用liburing提供的接口来进行异步IO请求的提交，liburing会根据用户的请求在共享内存中设置对应的参数。异步IO请求可以同时设置多个，这个过程中不发生系统调用，当用户设置好后再调用liburing的接口通知内核处理共享内存中的IO请求，从而实现操作的批量进行。

在这里插入图片描述

内核的io_uring模块在处理共享内存中的请求时，会根据请求的类型以及操作的文件所属的文件系统类型来调用不同的IO接口。具体异步程序的编写以及io_uring的实现原理将在下文详细介绍。

三、io_uring原理

3.1 ringBuf

从名字uring我们就可以看出来，该机制的核心即user和ring：其申请了一块用户态和内核态共享的内存，并在共享内存中通过ringBuf环形缓存队列的方式来实现内核态和用户态的通信，这里简单说一下该机制的使用和实现过程。

img

每一个io_uring实例，都会被分配一个fd，该过程是通过io_uring_setup()系统调用实现的。该系统调用会根据用户提供的参数，分配一块共享内存，该内存可以通过mmap()的方式映射到用户态。这块共享内存中，包含了一个SQ（提交队列）、一个CQ（完成队列）和一个SQE（提交实体）数组。其中，SQ和CQ是两个环形队列，队列中的元素是SQE在SQE数组中的偏移量，使用这种方式可以使得提交实体能够被随机访问，提高灵活性。用户从CQ的头部获取SEQ，将想要执行的操作（如文件的读写）初始化到其中，并添加到SQ队列的尾部，然后使用io_uring_enter()系统调用来进行提交队列的处理。

在这里插入图片描述

内核会从SQ中依次取出对应的提交实体，并根据提交实体中定义的动作来执行对应的操作。由于用户只操作SQ尾部，而内核只操作头部，因此两者对于共享队列的访问并不会产生冲突，节省了锁的开销。上图中为内核的处理流程简图，为了提高性能、降低时延，内核并不是一定会采用异步的方式来处理提交实体，而是会检查该实体所对应的文件系统是否支持非阻塞式的操作。对于块设备的读写，可能并不会支持非阻塞式操作，但是对于其他的一些文件系统，如网络套接字，是支持非阻塞式报文接收的。显而易见，当socket接收队列中存在报文时，进行异步报文读取无疑是不明智的，不仅会增加开销，还会导致收包的延迟。因此，内核会首先采用非阻塞的方式进行报文的读取，当收报队列中不存在报文时（会返回EAGAIN错误），才会将提交实体添加到异步队列，等待报文的到来。

在操作完成后，内核会将完成了的提交实体放到CQ队列的尾部，方便用户继续进行操作的提交。通过ringBuf的使用，io_uring获得了以下几点收益：

  • 能够以批量的方式进行IO的提交，减少了系统调用的次数，节省了开销；
  • 通过共享内存的使用，避免了用户态与内核态频繁的系统调用参数拷贝，提升了性能。

3.2 poll模式

为了进一步提高性能，io_uring还提供了两种轮询模式，即块设备层的iopoll轮询模式和提交sqpoll轮询模式。

3.2.1 iopoll

什么是IO轮询（poll）模式？轮询模式是相对于中断模式的。常规的块设备IO使用的都是中断模式，即进程将IO请求提交给块设备后会进入睡眠（D）状态，块设备在处理完IO请求后会触发硬中断，硬中断中会唤醒进程并通知其IO的完成。io_uring提供了一种block层的轮询模式，即IO请求提交后不进入睡眠，而是循环检查硬件设备的完成状态。该模式下，io_uring会额外启动一个内核进程来循环检查IO的完成。由于不需要等待硬件设备的通知，因此可以更快地获取到IO请求的完成，这对于延迟非常低以及IOPS很高的设备，能够显著提高性能，同时避免了高频的中断所带来的性能开销。

3.2.2 sqpoll

通过ringBuf的使用，我们现在可以批量地进行IO操作的提交，降低了系统调用次数。io_uring还提供了另一种机制用于进一步降低系统调用次数、提高IO效率，即：提交队列轮询SQPOLL模式。

在这里插入图片描述

该模式下，内核会启动一个内核进程专门用于SQE提交实体的处理，该进程会循环检查提交队列中是否存在实体。用户态程序只需要取出完成队列中的SEQ，进行初始化并添加到提交队列中即可，整个过程都不需要产生系统调用。为了降低开销，内核进程会有一个超时时间，在该时间段内如果都没有检测到提交队列中存在实体，就会进入睡眠状态，同时将进程的状态更新到共享内存中。用户进程在提交SQE之后，会通过该标志位检查poll进程是否在运行。若未运行，则通过io_uring_enter系统调用唤醒poll进程。

可以看出，在高IO频率的情况下，使用该模式可以大幅降低系统调用的次数，同时减少由于系统调用而带来的IO延迟。

3.3 固定文件和固定缓冲区

3.3.1 注册文件

每次将文件描述符填充到 sqe，然后提交给内核时，内核都必须检索对文件描述符的引用
当 IO 完成后，会再次删除文件引用，由于文件引用的原子性，这样对高 IOPS 的工作场景而言，速度会明显下降。
为了缓解此问题，io_uring 提供了一种对 io_uring 实例预注册文件集的方法

int io_uring_register(unsigned int fd, unsigned int opcode, void *arg, unsigned int nr_args);
  • fd 是 io_uring 实例的文件描述符
  • opcode 执行的注册类型。
    对于注册文件集来说，必须是 IORING_REGISTER_FILES。
  • arg 必须指向应用准备打开的文件描述符数组
  • nr_args 便是数组的大小

一旦 io_uring_register 成功将文件集注册后，应用就可以将文件集数组的索引（而不是使用实际的文件描述符）赋值给 sqe->fd 了，并设置 sqe->flags 字段为 IOSQE_FIXED_FILE 来标记 sqe->fd 是一个文件集索引

应用可以继续使用未注册的文件，即使是注册过的文件也可以通过文件描述符赋值 sqe->fd，sqe->flags不设置 IO_FIXED_FILE 来正常使用文件描述符

当 io_uring 实例被移除后，注册的文件集会自动释放，或者使用 IORING_UNREGISTER_FILES opcode 来调用 io_uring_register

3.3.2 注册缓冲区

不仅仅可以注册文件集，还可以注册一组固定 IO 缓冲区（fixed IO buffers)

使用 O_DIRECT 时，内核在真正执行 IO 前，必须映射应用内存页(pages) 到内核中，并且当 IO 完成后取消对这些页的映射。
这些操作的开销可能是昂贵的。如果应用可以复用 IO 缓冲区，那么总共只需要进行一次映射和取消映射，而不是每次 IO 操作都需要

要注册一组固定缓存区，io_uring_register 必须使用 IORING_REGISTER_BUFFERS 的 opcode 来调用，args 必须包含填充好每个 iovec 的地址和长度字段的 iovec 数组，nr_args 则是 iovec 数组的大小

成功注册固定缓冲区后，应用可以使用 IORING_OP_READ_FIXED 和 IORING_OP_WRITE_FIXED 在 IO 中利用这些缓冲区。
当使用 固定操作码(fixed op-codes) 时，sqe->addr 必须包含了那些固定缓冲区之一的索引，并且 sqe->len为请求的字节长度。
应用可能会注册大于 IO 操作的缓冲区，一个固定的读/写只是一个固定缓冲区的子集是完全合法的。

四、性能测试及分析

4.1 存储设备性能分析

4.1.1 快速存储芯片

在快速的存储设备上，如3D xpoint、SATA等，io_uring取得了可观的性能提升。以下为Linux-AIO、io_uring以及spdk的性能对比数据，该数据由io_uring的作者Jens Axboe提供。其中spdk是intel提出的从驱动层面实现的高性能存储设备框架，可以说是高性能存储方案中的标杆。该数据的测试方式为：在3D xpoint存储设备上进行4k大小的随机读取操作，衡量的指标为：

  • Latency：读取数据的延迟
  • IOPS：每秒内IO操作的次数，这里为每秒能够读取4k数据的次数
InterfaceQDPolledLatencyIOPS
io_uring109.5usec77K
io_uring208.2usec183K
io_uring408.4usec383K
io_uring8013.3usec449K
libaio109.7usec74K
libaio208.5usec181K
libaio408.5usec373K
libaio8015.4usec402K
io_uring116.1usec139K
io_uring216.1usec272K
io_uring416.3usec519K
io_uring8111.5usec592K
spdk116.1usec151K
spdk216.2usec293K
spdk416.7usec536K
spdk8112.6usec586K

从数据中可以看出，在非poll模式下，io_uring在IO延迟和IOPS上都有了些许的提升，提升效果似乎并不大。当开启了iopoll和sqpoll的情况下，内核进程会同时对提交队列和块设备驱动做轮询，此时能够达到最佳的IO性能。从数据中我们可以看出，当开启了poll模式后，io_uring在延迟和IOPS上的表现已经远远超越了AIO，并且已经可以媲美spdk了，特别是在高QD（Queue depth，一次性向设备发送多个IO请求）的情况下，甚至有赶超的趋势。

阿里云的团队对io_uring的性能也做了测评，其测评环境为：ecs.i2.2xlarge，8 vCPU 64 GiB，I2 本地存储 1788 GiB。测评结果显示，在进行顺序读写的情况下，io_uring性能提升明显，可达到160% ~ 170%；在进行随机读写时，性能提升可达到30% ~ 150%。测评数据如下所示：

  • 4k顺序读取：

在这里插入图片描述

  • 4k顺序写入：

在这里插入图片描述

  • 4k随机读取：

在这里插入图片描述

  • 4k随机写入：

在这里插入图片描述

4.1.2 普通机械硬盘

在速度比较慢的机械硬盘上，io_uring性能提升不明显。笔者在generic X86的PC下使用fio测试组件对io_uring的性能进行了测试，测试中所使用到的存储器为普通的机械硬盘，测试方式为进行4k的随机读操作，测试结果如下所示：

InterfaceQDPolledLatencyIOPS
sync1010.1msec131
sync409.8msec132
sync16010.3msec130
io_uring119.7msec133
io_uring4120.1msec201
io_uring16155.7msec286
io_uring109.9msec132
io_uring4020.2msec205
io_uring16055.5msec290

从结果中可以看出，由于同步IO方式并不支持多请求队列，因此延迟和IOPS基本没什么变化。而io_uring随着QD的增加，IOPS得到了显著的提升，在QD为16的时候更是提升了一倍以上，但是延迟也上升到了50毫秒。同时，是否处于poll模式对于硬盘IO基本上没有产生影响。

在对慢速的机械硬盘进行IO的时候，性能的瓶颈是低速的磁盘IO。因此这种情况下，相比于磁盘的IO速度，系统调用以及中断对性能造成的影响基本上可以忽略不计，所以在QD为1的时候io_uring与普通模式的IO性能没有什么差别。在QD提高的情况下，硬盘的IOPS得到了提升，IO带宽明显上升，但是由于机械硬盘的硬件性能较差，导致在同时处理多个IO请求时产生延迟明显升高的问题。这里我们可以看出，对于延迟不敏感的场景，使用io_uring可以更加充分地发挥机械硬盘的IO性能，获得较高的IO带宽。

4.2 网络性能测试

由于io_uring机制本身所引入的开销，其在网络报文处理方面出现了性能退化的问题。网络IO相比于存储器IO不太一样，网络IO本质上应该是属于CPU密集型场景，即影响网络吞吐量的是CPU的性能。因此对于网络IO，io_uring的目标应该是降低CPU开销。从上面的分析中我们可以看出，基于io_uring的报文收发能够降低系统调用次数，从而起到减少CPU开销的目的。由于poll模式本质是一种牺牲CPU开销来换取性能的手段，因此这里可能并不适用，这里我们就不考虑该模式。

测试方式：进行UDP收包，其中每个UDP报文的大小为1k。

模式报文量软中断CPU用户进程CPUCPU占用总量
sync10k/s37.8%31.6%69.4%
io_uring10k/s44.8%54.4%99.2%

从数据中我们可以看出，使用io_uring方式进行异步报文接收反而造成了CPU的升高，这是为什么呢？因为io_uring机制本身也会额外的产生开销。在进行异步报文接收时，由于操作是异步的，因此内核会将接收操作放到异步队列中并启动多个工作队列来处理收包请求，并将每个报文接收请求都链接到套接口的poll队列上等待报文到达后唤醒。额外的poll操作是CPU升高的一个原因，另一个原因是激烈是锁竞争。为了保证操作的一致性，io_uring使用了大量的自旋锁，在多个异步请求同时进行的情况下，锁竞争消耗了相当多的CPU。由此可见，在网络IO方面，io_uring还存在着一定的优化空间。

五、应用编程示例

5.1 liburing

直接使用系统调用来进行io_uring的开发还是比较复杂的，特别是需要对共享内存中的环形队列进行操作。所幸开源社区上提供了封装好的liburing库，大大简化了其使用。该库正是由io_uring的作者Jens Axboe实现的，其主要接口包括：

struct io_uring ring;
int io_uring_queue_init(unsigned entries, struct io_uring *ring, unsigned flags);

该接口用于io_uring实例的初始化，entries用于指定提交实例的数量；flags用于设置标志，比如用于启动iopoll模式的IORING_SETUP_IOPOLL，用于启动sqpoll模式的IORING_SETUP_SQPOLL等。

struct io_uring_sqe *io_uring_get_sqe(struct io_uring *ring)

获取一个空闲的提交实体用于IO的提交。

static inline void io_uring_prep_read(struct io_uring_sqe *sqe, int fd,
				      void *buf, unsigned nbytes, off_t offset)

该函数为提交实体初始化的封装，使用提供的参数将提交实体初始化为“读”操作。除此之外，还要write/send/recv/...等操作的封装函数，简化了代码的编写。

static inline void io_uring_sqe_set_data(struct io_uring_sqe *sqe, void *data)
static inline void *io_uring_cqe_get_data(const struct io_uring_cqe *cqe)

为提交实体设置（获取）私有数据，该数据为自定义数据，用于在提交实体完成后，从完成队列中获取到该对象时的识别等作用。

int io_uring_submit(struct io_uring *ring)

将提交队列中的SQE提交给内核处理。如果开启了SQPOLL模式，该函数不一定会陷入系统调用，只有在检查到内核进程没有运行的情况下才会产生系统调用。

static inline int io_uring_peek_cqe(struct io_uring *ring,
				    struct io_uring_cqe **cqe_ptr)
static inline int io_uring_wait_cqe(struct io_uring *ring,
				    struct io_uring_cqe **cqe_ptr)

从完成队列中获取完成实例，提供了阻塞和非阻塞两个版本。

5.2 编程示例

下面以UDP收包为例，来演示如何使用liburing来进行异步IO的实现。

#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>

#include "liburing.h"

#define MAX_PKT_SIZE    1500
#define MAX_PKT_COUNT   10

static void submit_recv(struct io_uring *ring, int sockfd, void *data)
{
        struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
        if (!sqe)
                return;

        io_uring_prep_recv(sqe, sockfd, data, MAX_PKT_SIZE, 0);
        io_uring_sqe_set_data(sqe, data);
}

static void submit_all_recv(struct io_uring *ring, int sockfd)
{
        struct io_uring_sqe *sqe;
        void *data;

    	//获取空闲的sqe
        while ((sqe = io_uring_get_sqe(ring))) {
                data = malloc(MAX_PKT_SIZE);
            	//将sqe初始化为recv操作
                io_uring_prep_recv(sqe, sockfd, data, MAX_PKT_SIZE, 0);
            	//设置sqe的私有数据，方便我们在操作完成后获取到其中的报文数据
                io_uring_sqe_set_data(sqe, data);
        }
}

static int do_recv(struct io_uring *ring, int sockfd)
{
        struct io_uring_cqe *cqe;
        void *data;
        int count;

    	//对提交数组中所有空闲的提交实体进行初始化，并放到提交队列
        submit_all_recv(ring, sockfd);
    	//将提交队列中的请求提交给内核处理
        io_uring_submit(ring);
        count = 0;

        while (true) {
            	//从完成队列中取出一个实例，返回非0的话代表完成队列中没有可取实例
                if (io_uring_peek_cqe(ring, &cqe)) {
                    	//进行一次提交操作，将提交队列中的请求批量提交给内核处理
                        io_uring_submit(ring);
                    	//以阻塞的方式等待完成队列中存在可用实例
                        io_uring_wait_cqe(ring, &cqe);
                }
                if (!cqe) {
                        fprintf(stderr, "io_uring_get_sqe failed\n");
                        continue;
                }
            	//获取完成实例中之前设置的私有数据
                data = io_uring_cqe_get_data(cqe);
                count++;
                if (!(count % 1000))
                        printf("recved packet count: %d, queue len:%d\n", count, io_uring_sq_ready(ring));
				//将完成实例标识为“完成处理”，其对应的提交实例可以被使用了
                io_uring_cqe_seen(ring, cqe);
            	//继续进行请求的提交。这里使用之前分配好的data，避免重复的内存分配
                submit_recv(ring, sockfd, data);
        }

        return 0;
}

int main()
{
        struct sockaddr_in saddr;
        struct io_uring ring;
        int ret, sockfd;

    	//初始化uring，设置提交队列长度为10
        ret = io_uring_queue_init(10, &ring, 0);
        if (ret < 0)
        {
                perror("queue_init");
                goto err;
        }

    	//初始化UDP套接字
        memset(&saddr, 0, sizeof(saddr));
        saddr.sin_family = AF_INET;
        saddr.sin_addr.s_addr = htonl(INADDR_ANY);
        saddr.sin_port = htons(8080);
        sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        ret = bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr));
        if (ret < 0)
        {
                perror("bind");
                goto err;
        }
    
    	//开始报文接收
        do_recv(&ring, sockfd);
err:
        return -1;
}

可以看出使用还是比较简洁的，用户也可以对liburing接口进行二次封装以达到更加简洁的目的。

六、基于io_uring的零拷贝展望

6.1 MSG_ZEROCOPY

MSG_ZEROCOPY是内核中现有的网络报文零拷贝技术，这个所谓的零拷贝技术，无论是实现还是取得的效果都有些差强人意。该技术是在三年前提出，它可以应用于各种常用网络协议的零拷贝收发，比如UDP、TCP、raw以及packet等，使用也很方便，只需要指定对应的套接字标志即可。以发包为例，其实现逻辑如下图所示：

在这里插入图片描述

首先，在创建套接口的时候，为套接口指定零拷贝的标志SO_ZEROCOPY，代表后面都用零拷贝的方式进行报文发送：

setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &one, sizeof(one))

然后，使用我们平时熟悉的send()或者sendmsg()进行消息的发送即可，发送的时候要指定MSG_ZEROCOPY标志，如下所示：

ret = send(fd, buf, sizeof(buf), MSG_ZEROCOPY);

报文的发送过程是异步的，当send()系统调用返回的时候，我们并不确定当前报文已经被网卡顺利的发送出去了，因此还需要一个机制来完成这项工作。MSG_ZEROCOPY利用了套接口的“错误队列”来实现这一机制，即当报文发送完成了，内核会往套接口的“错误队列”中放一条消息，用户检测到该消息后才可以重新使用这个报文缓冲区。因此，用户程序需要主动在当前套接口上进行poll()操作，以等待消息的到来，然后使用recvmsg()将该消息从错误队列中取出，判断其是我们关注的消息后，再继续报文的发送。这个过程的代码如下所示：

	pfd.fd = fd;
	pfd.events = 0;
	if (poll(&pfd, 1, -1) != 1 || pfd.revents & POLLERR == 0)
		error(1, errno, "poll");

	ret = recvmsg(fd, &msg, MSG_ERRQUEUE);
	if (ret == -1)
		error(1, errno, "recvmsg");

	read_notification(msg);

可以看出，虽然内核避免了内存拷贝，但是相比于传统的报文发送，该方式多了两次系统调用。综合衡量，不一定会取得性能的提升。根据作者的描述，当报文大小大于10k的时候，可能才会看到效果。

6.2 io_uring零拷贝

从上面的机制我们可以看出来，io_uring是一种通用的异步IO机制，其不限于块设备的IO，常规的基于文件的IO都可以使用。MSG_ZEROCOPY零拷贝技术的瓶颈就在于其通知机制引入了不必要的系统调用，如果使用io_uring来实现零拷贝，那么通知的问题就迎刃而解，因为io_uring本身就提供了使用完成队列来进行通知的功能。

对于这个思路，社区上的Jonathan Lemon（MSG_ZEROCOPY的维护者）已经在邮件系统上提过了（还没实现，不知道有没有在干活）：

MSG_ZEROCOPY_FIXED，io_uring-only sendmsg + recvmsg zerocopy

根据社区上的讨论，他们是想基于io_uring实现一个真·零拷贝技术，能够真正意义上使得网络报文的接收和发送过程中不产生数据拷贝：收包阶段，申请一块用户态共享内存，网卡收到报文后通过DMA直接将报文传递给用户态；发包阶段，基于io_uring的ringBuf，直接将用户态的报文数据传递给网卡硬件，并通过完成队列来实现完成消息的通知。该方案在技术上还存在一定的难点，可能还需要一定的时间才能面向大众。可以想象得到，当该方案实现的时候，网络性能将获得进一步的提升。

七、总结

本文对io_uring的实现原理以及其所取得的高性能表现做了简单介绍，可以看出该机制作为一种通用的IO机制具有强大的潜质，势必将成为日后主流的高性能异步IO解决方案。特别是CGEL中作为未来主力版本的Linux v5.4已经对该机制提供了充分的支持，内核侧无需做任何调整即可使用该特性。同时，本文对io_uring在网络报文零拷贝方面的研究现状也做了简单介绍，具体能给网络方面带来多大的性能提升，让我们拭目以待！

参考链接：【译】高性能异步 IO — io_uring(Effecient IO with io_uring)

仙人掌开叉
关注
  • 6
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
rio：纯锈io_uring库，基于libc构建，对线程和异步友好，抗滥用
02-03
rio：纯锈io_uring库，基于libc构建，对线程和异步友好，抗滥用
uring:用于io_uring框架的Golang库（无CGO）
05-23
io_uring是异步IO的新内核接口。 最好的介绍是。 请注意，该库主要在5.8。*内核上进行了测试。 虽然该库的核心未使用任何新功能，但将通过io_uring在内核上工作，该io_uring支持标志IORING_SETUP_CQSIZE和IORING_...
新一代异步IO框架 io_uring ｜ 得物技术
SmartCodeTech的博客
04-13 1019
得益于精妙的设计，io_uring的性能基本超越linux 内核以往任何软件层面的IO解决方案，达到了与硬件级解决方案媲美的性能。io_uring 需要较高版本的内核支持，目前还没有大面积普及，但可以预料他是 linux 内核 IO未来的核心发展方向。
Linux异步IO之 io_uring 详解及使用代码示例
weixin_46935110的博客
09-07 1654
Linux异步IO之 io_uring 详解及使用代码示例
io_uring的使用示例及其解释
最新发布
天使之翼
05-12 1001
这几个系统调用接口都在io_uring.c文件中。liburing 是io_uring的实现者Jens Axboe为了简化用户使用io_uring所实现的一个用户空间的 C 库，用于简化在 Linux 系统上使用 io_uring 的开发。它提供了一组简洁而强大的 API，使开发者可以更轻松地利用 io_uring 的高性能异步 I/O 功能，而无需深入了解 io_uring 的内部工作原理。
io_uring技术的分析与思考
dillanzhou的博客
12-03 9152
io_uring是Linux 5.1中引入的一套新的syscall接口，用于支持异步IO。近来这套机制颇受关注，很多人认为它代表了与内核实现高性能交互的一种模式。本文将对io_uring的原理和实现进行分析，了解其相对于原有IO机制的优势，并尝试预测其应用场景和发展趋势。 异步IO机制 在介绍io_uring之前，需要先了解一下其实现的异步IO机制，以及io_uring之前的异步IO是如何实现的。 在linux下，目前绝大部分程序中的IO操作都是同步的，最后通过read/write系列的系统调用实现对
深入理解Linux异步I/O框架 io_uring
极客重生
12-07 1839
、来源：云原生实验室hi，大家好，今天分享一篇Linux异步IO编程框架文章，对比IO复用的epoll框架，到底性能提高多少？让我们看一看。译者序本文组合翻译了以下两篇文章的干货部分，作...
网络编程 io_uring
xiaofeilongyu的博客
03-01 1160
io_uring高性能网络I/O处理
io_uring 使用教程| io_uring 完全指南 | io_uring 实践指导 | io_uring 资料参考
锐龙处理器
04-03 8533
io_uring 完全指南地图 背景 io_uring 是 2019 年做的，与 kernel 5.1 发布。后续打了很多补丁，比较重要的在 2020年5月之后基本达到了一个很好的可用性。学习这个东西和学习 epoll 系列的、学习 UNP 和 linux 网络编程其实没有什么区别，都是利用已有的工具解决问题，其实不涉及像学 OS、DBMS、分布式系统等这种系统方向技术上的东西，但是有一些惯常做法还是需要记录一下，如何利用工具，以及在工具的限制下解决问题也是一门形式化技术。本文只是提供一个使用 io_uri
io_uring-by-example:io_uring by Example文章系列的配套存储库
05-13
该程序在那里说明了同步I / O和异步io_uring API之间的区别。 02_cat_uring ：本示例使用io_uring提供的原始接口构建cat版本。 这样做是为了使用户了解io_uring界面在低层如何工作。 03_cat_liburing ：此示例在...
async:基于io_uring linux接口的现代后端开发框架
03-19
异步-使用io_ring事件循环的C ++后端开发框架。 =====异步是一组c ++原语，可让您在Linux系统上的c ++ 17中高效快速地进行开发。重点主要是后端开发，数据处理等。对依赖对依赖在cmake上使用ninja-build构建工件对...
异步使用io_uring定位I / O。-Rust开发
05-27
使用io_uring完全同步定位的I / O。 uring-positioned-io与io_uring完全同步的定位I / O。 限制读取缓冲区必须有效，直到读取完成。 这意味着您必须轮询一个已读的将来，直到完成为止。 您不能放弃阅读的未来。 基准...
关于 linux io_uring 性能测试 及其 实现原理的一些探索
天行健，地势坤
09-11 2865
从 io_uring on fio / rocksdb的一些测试记录 来体会io_uring的性能优势，从 io_uring 非poll 模式 以及 poll 模式的实现来看其性能优势以及发展前景。
io-uring的野心
weixin_38624424的博客
10-31 430
io-uring的野心 文章目录io-uring的野心网络的异步编程存储的异步编程io-uring的出世1.io-uring是什么？2.io-uring的实现原理是啥？io-uring的性能io-uring试用 网络的异步编程 网络存在着所谓的c10k问题（c10k问题链接），但随着软件与硬件发展都得到了较好的解决，先说linux上面，select, poll, epoll等并发度已经做的非常高了，但这三种网络模型依然存在着一个问题，那就是他们依然是同步的，比如服务器中常用的epoll, 它也是在某一个
基于协程io_uring 异步网络库系列 VI: io_uring v.s. epoll | proactor v.s. reactor | io_uring Proactor 模型
锐龙处理器
03-06 535
本文讲解 io_uring 如果编写 proactor 编程模型，同时对比 Reactor 模型。主要涉及的是模型中的 IO 部分，比如 short read。
高性能网络IO框架研究一：三种模式
Rocky的技术博客
08-29 825
IoT平台要求能够接入大规模的终端数据，因此对于底层的IO通信系统的性能和稳定性要求非常高。于是我对高性能IO框架进行了一些深入的研究。并将研究的内容总结出来，以供大家交流学习。
文件系统：3. io_uring-提交sqe
苟浩的博客
01-10 446
文件系统：3. io_uring-提交sqe
性能媲美epoll的io_uring
禹鼎侯的博客
05-23 560
io_uring通过队列将send和recv的数据做到异步解耦，从而提升了性能，但是相比于epollio_uring过分依赖于内核版本（kerner5.10以上），且操作相对比较繁琐。因此，现阶段可以作为了解，主流使用应该还是以epoll为主。C/C++Linux服务器开发/高级架构师。
io_uring异步io简介
rayylee
06-29 957
io_uring 是facebook开发的，从 5.1 就进 Linux 内核主线了，但陆续改进到 5.11 才有了 kLoop 需要的全部功能，并且仍在持续改进中。笼统来讲，应用程序用内存映射（mmap）的方式拿到两条与内核共享的环状队列，通过其中一条队列（SQ）给内核源源不断的布置任务，然后从另外一条队列（CQ）获取结果；内核则按需进行 epoll()，并在一个线程池中执行就绪的任务。...
linux 异步io
09-08
Linux异步IO是指在Linux操作系统中，通过使用异步IO技术来实现对文件或网络数据的非阻塞读写操作。Linux的异步IO发展过程中曾经经历了一些曲折，没有一个完美的实现。与Windows下的异步IO相比，Linux的异步IO实现相对不够成熟，没有像IOCP（Input/Output Completion Port）那样被广泛认可。这种异步IO也被称为Linux Kernel AIO（Asynchronous I/O）或者Native AIO，因为它是由Linux内核提供的API。目前，Linux异步IO的实现相对较为复杂，但在将来随着Linux 5.1以上版本的更新，如果io_uring技术能够得到很好的发展，Linux异步IO有可能成为主流。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值