存储课程学习笔记5_iouring的练习（io_uring,rust_echo_bench,fio）

yun6853992

已于 2024-09-10 16:21:57 修改

阅读量893

点赞数 4

分类专栏： dpdk学习文章标签： io_uring fio

于 2024-09-10 16:20:32 首次发布

本文链接：https://blog.csdn.net/yun6853992/article/details/142102152

版权

dpdk学习专栏收录该内容

18 篇文章 17 订阅

订阅专栏

我们知道，在处理大量高并发网络时，一般考虑并发，以及设计对应的方案（比如select,poll,epoll）等。

那么如果频繁进行文件或者磁盘的操作，如何考虑性能和并发，这里就可以考虑用到io_uring。

0：总结

1：实际上主要用liburing库对io_uring的使用进行测试。

2：使用新的开源库，实际上从库中对应的example中开始进行逻辑分析是最合理的。

3：io_uring 高效异步IO方案，可以用于磁盘，数据库，大规模io处理，网络等方向（这里以作为tcp server测试）。

4：可以用开源库rust_echo_bench 对服务器性能进行测试。

5：可以用fio对磁盘读写性能进行测试

1：环境准备

使用io_uring需要linux内核的支持，linux内核(注意版本)中提供了对io_uring的支持，主要是三个系统调用io_uring_setup,io_uring_register,ui_uring_enter。

使用liburing（已经进行必要的封装）对io_uring的调用测试（可以分析相关源码调用上面三个接口的逻辑）。

安装liburing库，测试相关demo。

tar -zxvf liburing-liburing-2.6.tar.gz 
cd liburing-liburing-2.6/
./configure 
make
sudo make install

2：简单分析实现流程。

总流程分析：

===》1：初始化一个struct io_uring 对象，核心对象。

===》2：构造必要的struct io_uring_sqe对象，该结构体有个字段opcode，作为操作码识别要执行的操作。比如缓冲区的读，写，以及网络支持的connect或者accept,以及其他相关。

===》3：把构造的sqe提交给内核。

===》4：等待事件的完成 io_uring_wait_cqe会阻塞等待cqe的返回。（可以研究等待时间）

===》5：从cqe中取出已经完成的事件，进行处理。

===》6：最后，依次重复上面的循环，按业务进行处理。

//可以参考liburing下的相关example有各种功能的demo

//初始化一个struct io_uring 对象
struct io_uring ring;
int ret = io_uring_queue_init(128, &ring, 0); //设置ringbuffer大小128 

//构造sqe对象 这里构造支持的是accept接收的对象 直接用liburing中封装的接口
struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
io_uring_prep_accept(sqe, sockfd, addr, addrlen, flags);

//每一个cqe构造后，要提交后才有效
//这里以网络场景为demo   文件fd的操作逻辑一样。
while(1)
{
    io_uring_submit(&ring);
    
    //等待已经完成的事件  liburing会把上面的sqe事件请求结果放入cqe中 进行处理
    struct io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe); //阻塞等待至少一个事件完成

    //直接拿出多个已完成事件 
    struct io_uring_cqe *cqes[10];
    int cqecount = io_uring_peek_batch_cqe(&ring, cqes, 10);
    
    //对cqes中的事件进行处理 其他业务...
}

在网上随便找了一个图，实际上要处理的事件放入sq队列中，已经完成的事件从下面的cq队列中取出，其他由内核底层支持：
在这里插入图片描述

3：简单实现一个tcp server代码demo

异步io io_uring提供了两个进程和内核共享的队列：提交队列（submission queue, SQ）和完成队列（completion queue, CQ）。进程只需要向队列提交I/O请求即可，支持一次性多个io请求提交。

这里在测试时想到有关非阻塞io的概念，非阻塞时针对操作fd时read write函数时的操作，这里异步不涉及。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "liburing.h"

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

enum {
	EVENT_ACCEPT = 0,
	EVENT_READ,
	EVENT_WRITE
};

typedef struct _conninfo {
	int connfd;
	int event;
} conninfo;

int init_sock();
void print_client_info(struct sockaddr_in *client_addr);
void set_accept_event(struct io_uring *ring, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
void set_recv_event(struct io_uring *ring, int sockfd, void *buf, size_t len, int flags) ;
void set_send_event(struct io_uring *ring, int sockfd, void *buf, size_t len, int flags); 

int main()
{
	//初始化socket  创建并bind listen
	int sockfd = init_sock();
	if(sockfd < 0){
		return -1;
	}

	//初始化io_uring实例  简单的用io_uring_queue_init  额外参数设置可以用 io_uring_queue_init_params
	//实际上io_uring_queue_init 内部调用的也是 io_uring_queue_init_params 
	struct io_uring ring;
	int ret = io_uring_queue_init(128, &ring, 0);
	if (ret < 0) {
		fprintf(stderr, "queue_init: %s\n", strerror(-ret));
{
		return 1;
	}

	//可以用额外参数设置 特定行为 研究参数结构体struct io_uring_params，设置sqe cqe 大小，设置iopoll模式来进行 I/O 完成事件等待，默认是通过阻塞方式等待
	// struct io_uring_params params;
	// memset(&params, 0, sizeof(params));

	// struct io_uring ring;
	// io_uring_queue_init_params(1024, &ring, &params);

	//定义用于执行accept操作事件    这里定义用于存储连接客户端的信息。
	struct sockaddr_in clientaddr;
	socklen_t clilen = sizeof(struct sockaddr);

	//获取sqe用于提交异步执行的accept操作 需要设置sqe中对应的user_data 的标志  用于标志对应事件    
	set_accept_event(&ring, sockfd, (struct sockaddr*)&clientaddr, &clilen, 0);

	//只是简单的测试demo   打印回环发送  公用一个buffer 
	char buffer[1024] = {0};
	//已经accept了，开始进行服务器实现。 
	conninfo ci;
	while(1)
			//每一次的事件都要进行提交才有效 
		io_uring_submit(&ring);

		//等待已经完成的事件  liburing会把上面的sqe事件请求结果放入cqe中 进行处理
		struct io_uring_cqe *cqe;
		io_uring_wait_cqe(&ring, &cqe);

		struct io_uring_cqe *cqes[10];
		int cqecount = io_uring_peek_batch_cqe(&ring, cqes, 10);

		//已经获取到已经完成的事件 一一进行分别处理
		for(int i=0; i<cqecount; i++)
		{
			cqe = cqes[i];

			//获取对应的事件 一一进行处理 获取自己上面设置过的事件 进行实际处理
			memcpy(&ci, &cqe->user_data, sizeof(ci));

			//对不同的事件进行处理 
			if(ci.event == EVENT_ACCEPT){
				if (cqe->res < 0) continue; // 对完成结果先进行判断 如果负数 则表示失败 正数 则返回的连接fd

				//说明已经有了一个连接  进行打印 
				printf("connectfd : %d  ", cqe->res);
				print_client_info(&clientaddr);

				//对原有的fd进行继续accent 
				set_accept_event(&ring, ci.connfd, (struct sockaddr*)&clientaddr, &clilen, 0);
				//对新的fd进行recv事件的监听
				set_recv_event(&ring, cqe->res, buffer, 1024, 0);

			} else if (ci.event == EVENT_READ) { //投递读请求  注意读完数据 简单demo
				if (cqe->res < 0) continue; // 对完成结果先进行判断 如果负数 则表示失败 正数 则返回的数据长度吧
				if (cqe->res == 0) { //这里用户数据已经放入了 连接fd了
					printf("close socket fd: %d \n", ci.connfd);
					close(ci.connfd);

				} else {

					printf("recv --> %s, %d\n", buffer, cqe->res);
					//根据业务 简单实现  回复事件的投递
					set_send_event(&ring, ci.connfd, buffer, cqe->res, 0);
				}

			} else if (ci.event == EVENT_WRITE) { // 上面set_send_event 投递了发送  这里已经发送完成了 
				if (cqe->res < 0)  //cqe只展示了返回结果 
				{
					printf("send data error: %d \n", cqe->res);
					// continue;
				}else
					printf("send success --> %s, %d\n", buffer, cqe->res);

				//继续进行监听 那如果超过1024字节 会怎样？
				memset(buffer, 0, 1024);
				set_recv_event(&ring, ci.connfd, buffer, 1024, 0); //注意  这里的res是send返回的结果 不是上面的connfd
			}

		}
		io_uring_cq_advance(&ring, cqecount);
	}
	return 0;
}

void print_client_info(struct sockaddr_in *client_addr) 
{
    char client_ip[INET_ADDRSTRLEN];  // 缓存用于存储IP地址的字符串
    int client_port;

    // 将IP地址转换为字符串形式
    inet_ntop(AF_INET, &(client_addr->sin_addr), client_ip, INET_ADDRSTRLEN);

    // 将端口号从网络字节序转换为主机字节序
    client_port = ntohs(client_addr->sin_port);

    // 打印客户端的IP地址和端口
    printf("Client IP:Port===> %s:%d \n", client_ip, client_port);
}


int init_sock()
{
	int sockfd = socket(AF_INET, SOCK_STREAM, 0); // io
	
	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(struct sockaddr_in)); // 
	servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0
    servaddr.sin_port = htons(9999);

    int reuse = 1; // 开启可重用选项
	if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
	    perror("setsockopt(SO_REUSEADDR) failed");
	    // 处理错误情况
	    return -1;
	}

    if (-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))) {
		printf("bind failed: %s", strerror(errno));
		return -1;
    }

    listen(sockfd, 10); 
    printf("socket fd has listen: 9999。\n");
    return sockfd;
}

void set_accept_event(struct io_uring *ring, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) 
{
	// 获取一个空闲的SQE（Submission Queue Entry）来设置要提交的I/O操作请求
	struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
	
    io_uring_prep_accept(sqe, sockfd, addr, addrlen, flags);
    conninfo info_accept = {
        .connfd = sockfd,
        .event = EVENT_ACCEPT,
    };
    memcpy(&sqe->user_data, &info_accept, sizeof(info_accept));

}

//同样获取sqe 投递recv事件 同时修改userdata标志 方便后面处理 
void set_recv_event(struct io_uring *ring, int sockfd, void *buf, size_t len, int flags) 
{
	struct io_uring_sqe *sqe = io_uring_get_sqe(ring);

	io_uring_prep_recv(sqe, sockfd, buf, len, flags);
	conninfo info_recv = {
		.connfd = sockfd,
		.event = EVENT_READ,
	};
	memcpy(&sqe->user_data, &info_recv, sizeof(info_recv));

}

//投递发送数据 buffer已经放入
void set_send_event(struct io_uring *ring, int sockfd, void *buf, size_t len, int flags)
{
	struct io_uring_sqe *sqe = io_uring_get_sqe(ring);

	io_uring_prep_send(sqe, sockfd, buf, len, flags);
	conninfo info_send = {
		.connfd = sockfd,
		.event = EVENT_WRITE,
	};
	memcpy(&sqe->user_data, &info_send, sizeof(info_send));
}

4：编译后进行测试

这里实现的是一个回环的功能，客户端发来的数据会原本回馈

#这是对应测试代码的测试结果 两个网络助手  一个telnet进行测试
ubuntu@ubuntu:~/start_test$ gcc uring_server.c -o uring_server -luring
ubuntu@ubuntu:~/start_test$ ./io_uring 
socket fd has listen: 9999。
connectfd : 5  Client IP:Port===> 127.0.0.1:44104 
connectfd : 6  Client IP:Port===> 192.168.40.1:63174 
recv --> http://www.cmsoft.cn QQ:10865600, 32
send success --> http://www.cmsoft.cn QQ:10865600, 32
connectfd : 7  Client IP:Port===> 192.168.40.1:63186 
recv --> 123456789, 9
send success --> 123456789, 9
close socket fd: 5 
close socket fd: 7 
close socket fd: 6 
#同时  这里发现 客户端发送很长的数据，服务端也能依次正常收到  然后发送给客户端

客户端用网络传输助手，和telnet 指令进行测试

ubuntu@ubuntu:~$ telnet 127.0.0.1 9999
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
123456789
123456789
^]
telnet> quit   #这里的退出 按键ctrl+] 进入指令这里 输入quit退出telnet
Connection closed.

5：借助开源库rust_echo_bench可以测试服务器网络请求性能（测试io_uring和epoll之间的性能）

ubuntu@ubuntu:~/uring$ git clone https://github.com/haraldh/rust_echo_bench.git
ubuntu@ubuntu:~/uring/rust_echo_bench$ cat .git/config 
[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true
[remote "origin"]
	url = https://github.com/haraldh/rust_echo_bench.git
	fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
	remote = origin
	merge = refs/heads/master

#启动io_uring实现的tcp server服务
ubuntu@ubuntu:~/uring/rust_echo_bench$ gcc uring_server.c -o uring_server -luring
ubuntu@ubuntu:~/uring/rust_echo_bench$ ./uring_server
#测试io_uring
ubuntu@ubuntu:~/uring/rust_echo_bench$ cargo run --release -- --address "127.0.0.1:9999" --number 1000 --duration 20 --length 512
    Finished release [optimized] target(s) in 0.09s
     Running `target/release/echo_bench --address '127.0.0.1:9999' --number 1000 --duration 20 --length 512`
Benchmarking: 127.0.0.1:9999
1000 clients, running 512 bytes, 20 sec.

Speed: 43747 request/sec, 43716 response/sec
Requests: 874941
Responses: 874321
ubuntu@ubuntu:~/uring/rust_echo_bench$ cargo run --release -- --address "192.168.40.129:9999" --number 1000 --duration 20 --length 512
    Finished release [optimized] target(s) in 0.07s
     Running `target/release/echo_bench --address '192.168.40.129:9999' --number 1000 --duration 20 --length 512`
Benchmarking: 192.168.40.129:9999
1000 clients, running 512 bytes, 20 sec.

Speed: 45077 request/sec, 45047 response/sec
Requests: 901542
Responses: 900947

#测试epoll 启动对应epoll实现的tcp server服务
ubuntu@ubuntu:~/uring/uring-main$ gcc multi-io.c -o multi-io
ubuntu@ubuntu:~/uring/uring-main$ ./multi-io
#进行测试
ubuntu@ubuntu:~/uring/rust_echo_bench$ cargo run --release -- --address "192.168.40.129:9999" --number 1000 --duration 20 --length 512
    Finished release [optimized] target(s) in 0.09s
     Running `target/release/echo_bench --address '192.168.40.129:9999' --number 1000 --duration 20 --length 512`
Benchmarking: 192.168.40.129:9999
1000 clients, running 512 bytes, 20 sec.

Speed: 47051 request/sec, 47031 response/sec
Requests: 941026
Responses: 940637

===>经过测试  当前局域网环境，网络上 1000个链接  20s  512byte  epoll和io_uring性能差距不大

6：借助fio可以测试磁盘的读写性能。

6.1 安装fio

tar -zxvf fio-fio-3.37.tar.gz 
cd fio-fio-3.37/
./configure 
make
sudo make install

6.2 fio相关参数和结果报告中参数说明

#使用fio进行测试 相关参数描述
当使用FIO进行磁盘测试时，可以使用多个参数来配置测试的行为。以下是一些常用的参数及其作用：
--name：指定测试作业的名称。
--ioengine：指定底层I/O引擎，例如sync、libaio、mmap等。
--rw：指定读写模式，如randread(随机读)、randwrite(随机写)、read(顺序读)、write(顺序写)等。
--bs：指定块大小，单位可以是字节（B）、千字节（KB）、兆字节（MB）或者块大小（如4K）。
--numjobs：指定并发线程数。
--size：指定测试数据的大小，单位同样可以是B、KB、MB或者以块大小为单位。
--runtime：指定测试运行时间。
除了上述基本参数外，还有其他一些高级配置选项可供选择：

--iodepth: 指定每个工作线程在队列中同时挂起的I/O请求数量，默认值为1.   每个工作线程可以同时请求io的数量，一起执行，等待完成后再下一次。
--ramp_time: 指定测试开始前的预热时间，默认为0秒.
--filename: 指定测试使用的文件名或设备路径.
--group_reporting: 将报告显示合并为一个总结报告

结果中相关参数说明：

#对结果进行分析
Run status group 0 (all jobs):
   READ: bw=16.0MiB/s (16.8MB/s), 16.0MiB/s-16.0MiB/s (16.8MB/s-16.8MB/s), io=321MiB (337MB), run=20001-20001msec
   
READ: 表示该作业是一个读取操作。
bw=16.0MiB/s (16.8MB/s): 读取速度为16.0 MiB/s（或者可以理解为16.8 MB/s）。
16.0MiB/s-16.0MiB/s (16.8MB/s-16.8MB/s): 表示读取速度范围在16.0 MiB/s到16.0 MiB/s之间（或者可以理解为范围在16.8 MB/s到16.8 MB/s之间）。
io=321MiB (337MB): 总共读取了321 MiB的数据（或者可以理解为337 MB）。
run=20001-20001msec：该作业运行时间为20001毫秒。
这些统计信息提供了关于读取操作的性能和工作情况的细节

Disk stats (read/write):
    dm-0: ios=223993/4, sectors=1791944/32, merge=0/0, ticks=39208/0, in_queue=39208, util=98.14%, aggrios=225391/3, aggsectors=1803128/32, aggrmerge=0/1, aggrticks=36357/1, aggrin_queue=36359, aggrutil=98.06%
  sda: ios=225391/3, sectors=1803128/32, merge=0/1, ticks=36357/1, in_queue=36359, util=98.06%
  
这段输出结果描述了磁盘统计信息，包括读取和写入操作的情况。下面是对每个字段的解释：
dm-0: 这是一个逻辑卷设备（logical volume）的名称。
ios=223993/4: 总共进行了223,993次读取操作和4次写入操作。
sectors=1791944/32: 读取了1,791,944个扇区（sector），写入了32个扇区。
merge=0/0: 没有发生合并操作。
ticks=39208/0: 读取操作耗时39,208个时钟滴答，写入操作没有耗时。
in_queue=39208: 当前队列中等待执行的I/O请求数量。
util=98.14%: 磁盘利用率达到了98.14%，表示磁盘处于高负载状态。
接下来是针对整个磁盘设备（sda）的统计信息：

ios=225391/3: 总共进行了225,391次读取操作和3次写入操作。
sectors=1803128/32：读取了1,803,128个扇区，写入了32个扇区。
merge=0/1：未发生合并操作，但可能进行了一次分散或聚集操作。
ticks=36357/1：读取操作耗时36,357个时钟滴答，写入操作耗时1个时钟滴答。
in_queue=36359：当前队列中等待执行的I/O请求数量。
util=98.06%：磁盘利用率达到了98.06%，表示磁盘处于高负载状态。
这些统计信息可以帮助评估磁盘的性能和负载情况，例如通过观察读取和写入操作的数量、扇区数以及耗时情况，可以了解磁盘的工作状态和效率。同时也可以关注磁盘队列中等待执行的I/O请求数量，以及磁盘利用率来评估系统的整体性能。

6.3 使用fio简单进行测试磁盘性能。

fio提供了不同的读写磁盘的io引擎方式，比如sync，libaio, io_uring,mmap等，可以分别测试。

测试前可以用dd指令创建合适大小的文件，改变–filename参数进行测试，这里直接用nvme磁盘测试。

可以控制变量，改变不同的参数查看结果进行对比，如果，如果改变–numjobs指定并发线程数，观察性能变化。

#简单使用fio对磁盘读，写性能进行测试。
#测试posix api    read/write     psync (简写 io引擎)

#查看支持的io引擎 
root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --enghelp
Available IO engines:
	cpuio
	mmap
	sync
	psync
	vsync
	pvsync
	pvsync2
	null
	net
	netsplice
	ftruncate
	filecreate
	filestat
	filedelete
	dircreate
	dirstat
	dirdelete
	exec
	posixaio
	falloc
	e4defrag
	splice
	mtd
	sg
	io_uring
	io_uring_cmd
	libaio

#测试随机读
root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=psync --iodepth=1 --rw=randread --bs=4k --numjobs=1 --size=1G --runtime=20 --filename=/dev/nvme0n1

Run status group 0 (all jobs):
   READ: bw=19.8MiB/s (20.7MB/s), 19.8MiB/s-19.8MiB/s (20.7MB/s-20.7MB/s), io=396MiB (415MB), run=20001-20001msec

Disk stats (read/write):
  nvme0n1: ios=100744/0, sectors=805952/0, merge=0/0, ticks=17283/0, in_queue=17283, util=99.71%
 
 #mmap
root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=mmap --iodepth=1 --rw=randread --bs=4k --numjobs=1 --size=1G --runtime=20 --filename=/dev/nvme0n1
Run status group 0 (all jobs):
   READ: bw=13.3MiB/s (13.9MB/s), 13.3MiB/s-13.3MiB/s (13.9MB/s-13.9MB/s), io=265MiB (278MB), run=20001-20001msec

Disk stats (read/write):
  nvme0n1: ios=67590/0, sectors=540720/0, merge=0/0, ticks=17700/0, in_queue=17700, util=99.69%

root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=io_uring --iodepth=1 --rw=randread --bs=4k --numjobs=1 --size=1G --runtime=20 --filename=/dev/nvme0n1

Run status group 0 (all jobs):
   READ: bw=16.5MiB/s (17.3MB/s), 16.5MiB/s-16.5MiB/s (17.3MB/s-17.3MB/s), io=331MiB (347MB), run=20001-20001msec

Disk stats (read/write):
  nvme0n1: ios=84263/0, sectors=674104/0, merge=0/0, ticks=17474/0, in_queue=17474, util=99.66%
  
#改变每个线程挂起队列数 以及同时运行的线程数为4
root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=io_uring --iodepth=128 --rw=randread --bs=4k --numjobs=4 --size=1G --runtime=20 --filename=/dev/nvme0n1
Run status group 0 (all jobs):
   READ: bw=61.4MiB/s (64.3MB/s), 5787KiB/s-21.9MiB/s (5925kB/s-22.9MB/s), io=2048MiB (2147MB), run=32290-33378msec

Disk stats (read/write):
  nvme0n1: ios=251113/0, sectors=2008904/0, merge=0/0, ticks=5234262/0, in_queue=5234262, util=97.34%



######################################
#测试随机写
root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=psync --iodepth=1 --rw=randwrite --bs=4k --numjobs=1 --size=1G --runtime=20 --filename=/dev/nvme0n1

Run status group 0 (all jobs):
  WRITE: bw=785MiB/s (823MB/s), 785MiB/s-785MiB/s (823MB/s-823MB/s), io=1024MiB (1074MB), run=1304-1304msec

Disk stats (read/write):
  nvme0n1: ios=50/1809, sectors=2104/117296, merge=0/13018, ticks=19/1443, in_queue=1462, util=20.56%
#mmap
root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=mmap --iodepth=1 --rw=randwrite --bs=4k --numjobs=1 --size=1G --runtime=20 --filename=/dev/nvme0n1
Run status group 0 (all jobs):
  WRITE: bw=3484KiB/s (3568kB/s), 3484KiB/s-3484KiB/s (3568kB/s-3568kB/s), io=137MiB (144MB), run=40339-40339msec

Disk stats (read/write):
  nvme0n1: ios=35184/28647, sectors=283176/281072, merge=0/6487, ticks=9031/27289, in_queue=36321, util=27.70%

#libaio
root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=libaio --iodepth=1 --rw=randwrite --bs=4k --numjobs=1 --size=1G --runtime=20 --filename=/dev/nvme0n1
test: (g=0): rw=randwrite, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=libaio, iodepth=1
Run status group 0 (all jobs):
  WRITE: bw=361MiB/s (379MB/s), 361MiB/s-361MiB/s (379MB/s-379MB/s), io=1024MiB (1074MB), run=2834-2834msec

Disk stats (read/write):
  nvme0n1: ios=51/4434, sectors=2112/310064, merge=0/36071, ticks=26/14927, in_queue=14952, util=23.94%

root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=io_uring --iodepth=1 --rw=randwrite --bs=4k --numjobs=1 --size=1G --runtime=20 --filename=/dev/nvme0n1

Run status group 0 (all jobs):
  WRITE: bw=36.0MiB/s (37.8MB/s), 36.0MiB/s-36.0MiB/s (37.8MB/s-37.8MB/s), io=721MiB (756MB), run=20001-20001msec

Disk stats (read/write):
  nvme0n1: ios=49/51479, sectors=2096/836976, merge=0/53143, ticks=13/82485, in_queue=82499, util=10.92%
 
#每个工作线程在队列中同时挂起的I/O请求数量128 并指定线程数为4  
root@ubuntu:/home/ubuntu/uring/fio-fio-3.37# ./fio --name=test --ioengine=io_uring --iodepth=128 --rw=randwrite --bs=4k --numjobs=4 --size=1G --runtime=20 --filename=/dev/nvme0n1

Run status group 0 (all jobs):
  WRITE: bw=638MiB/s (669MB/s), 160MiB/s-187MiB/s (167MB/s-196MB/s), io=4096MiB (4295MB), run=5470-6417msec

Disk stats (read/write):
  nvme0n1: ios=51/23432, sectors=2112/2844440, merge=0/332175, ticks=13/227712, in_queue=227724, util=51.16%

按需求需要，设置参数分析不同参数下的磁盘性能。

yun6853992

关注

4
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
存储课程学习笔记5_iouring的练习（io_uring,rust_echo_bench,fio）

1：实际上主要用liburing库对io_uring的使用进行测试。2：使用新的开源库，实际上从库中对应的example中开始进行逻辑分析是最合理的。3：io_uring 高效异步IO方案，可以用于磁盘，数据库，大规模io处理，网络等方向（这里以作为tcp server测试）。4：可以用开源库rust_echo_bench 对服务器性能进行测试。5：可以用fio对磁盘读写性能进行测试。
复制链接

扫一扫