Linux下磁盘IO读写测试工具-FIO详解

Posted 2021-11-22 Echo&.

FIO简介

FIO是Linux下开源的一款IOPS测试工具，主要用来对磁盘进行压力测试和性能验证。
它可以产生许多线程或进程来执行用户特定类型的I/O操作，通过编写作业文件（类似于k8s的yaml）或者直接命令去执行测试动作，相当于是一个 多线程的io生成工具，用于生成多种IO模式来测试硬盘设备的性能（大多情况用于测试裸盘性能）。

硬盘I/O测试主要有以下类型：

• 随机读、随机写
• 顺序读、顺序写

（fio测试时可根据需求设置70%读，30%写或100%读等等）

FIO的安装与使用

github地址：https://github.com/axboe/fio
下载安装方式：

$ yum -y install libaio-devel		#安装libaio引擎，不然执行fio会报“fio: engine libaio not loadable”，必须要在fio安装前安装，不然还要重新编译安装一遍fio
$ wget https://github.com/axboe/fio/archive/refs/tags/fio-3.10.zip
$ cd /root/fio-fio-3.10
$ ./configure
$ mke && make install

软件包内也包含了最详细的FIO官方HOWTO文档，有兴趣的可以看一看，路径：/root/fio-fio-3.10/HOWTO

常用参数介绍

-filename=/dev/sdb		#要测试盘的名称，支持文件系统或者裸设备，/dev/sda2或/dev/sdb
-direct=1		 #测试过程绕过机器自带的buffer，使测试结果更真实（Linux在读写时，数据会先写到缓存，再在后台写到硬盘，读的时候也是优先从缓存中读，这样访问速度会加快，但是一旦掉电，缓存中数据就会清空，所有一种模式为DirectIO，可以跳过缓存，直接读写硬盘）
-ioengine=libaio		#定义使用什么io引擎去下发io请求，常用的一些 libaio：Linux本地异步I/O；rbd:通过librbd直接访问CEPH Rados 
-iodepth=16		 #队列的深度为16，在异步模式下，CPU不能一直无限的发命令到硬盘设备。比如SSD执行读写如果发生了卡顿，那有可能系统会一直不停的发命令，几千个，甚至几万个，这样一方面SSD扛不住，另一方面这么多命令会很占内存，系统也要挂掉了。这样，就带来一个参数叫做队列深度。
-bs=4k           #单次io的块文件大小为4k
-numjobs=10      #本次测试的线程数是10
-size=5G         #每个线程读写的数据量是5GB
-runtime=60      #测试时间为60秒，可以设置2m为两分钟。如果不配置此项，会将设置的size大小全部写入或者读取完为止
-rw=randread     #测试随机读的I/O
-rw=randwrite    #测试随机写的I/O
-rw=randrw       #测试随机混合写和读的I/O
-rw=read         #测试顺序读的I/O
-rw=write        #测试顺序写的I/O
-rw=rw           #测试顺序混合写和读的I/O
-thread          #使用pthread_create创建线程，另一种是fork创建进程。进程的开销比线程要大，一般都采用thread测试
rwmixwrite=30    #在混合读写的模式下，写占30%（即rwmixread读为70%，单独配置这样的一个参数即可）
-group_reporting     #关于显示结果的，汇总每个进程的信息
-name="TDSQL_4KB_read_test"     #定义测试任务名称
扩展
-lockmem=1g       #只使用1g内存进行测试
-zero_buffers     #用全0初始化缓冲区，默认是用随机数据填充缓冲区
-random_distribution=random    #默认情况下，fio 会在询问时使用完全均匀的随机分布，有需要的话可以自定义访问区域，zipf、pareto、normal、zoned
-nrfiles=8        #每个进程生成文件的数量

测试场景示例

100%随机读，5G大小，4k块文件：

fio -filename=/dev/sdb \\
-direct=1 -ioengine=libaio \\
-bs=4k -size=5G -numjobs=10 \\
-iodepth=16 -runtime=60 \\
-thread -rw=randread -group_reporting \\
-name="TDSQL_4KB_randread_test"

100%顺序读，5G大小，4k块文件：

fio -filename=/dev/sdb \\
-direct=1 -ioengine=libaio \\
-bs=4k -size=5G -numjobs=10 \\
-iodepth=16 -runtime=60 \\
-thread -rw=read -group_reporting \\
-name="TDSQL_4KB_write_test"

70%随机读，30%随机写，5G大小，4k块文件：

fio -filename=/dev/sdb \\
-direct=1 -ioengine=libaio \\
-bs=4k -size=5G -numjobs=10 \\
-iodepth=16 -runtime=60 \\
-thread -rw=randrw -rwmixread=70 \\
-group_reporting \\
-name="TDSQL_4KB_randread70-write_test"

70%顺序读，30%随机写，5G大小，4k块文件：

fio -filename=/dev/sdb \\
-direct=1 -ioengine=libaio \\
-bs=4k -size=5G -numjobs=10 \\
-iodepth=16 -runtime=60 \\
-thread -rw=rw -rwmixread=70 \\
-group_reporting \\
-name="TDSQL_4KB_read70-write_test"

其实重点也就在于设置合适的读写类型和读写占比就可以了

输出报告

这里就用本地的虚拟机来简单测试一下了（裸盘测试）

[root@localhost fio-fio-3.10]# fio -filename=/dev/sdb \\
> -direct=1 -ioengine=libaio \\
> -bs=4k -size=5G -numjobs=10 \\
> -iodepth=16 -runtime=60 \\
> -thread -rw=randrw -rwmixread=70 \\
> -group_reporting \\
> -name="local_randrw_test"
local_randrw_test: (g=0): rw=randrw, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=libaio, iodepth=16
...
fio-3.10
Starting 10 threads
Jobs: 10 (f=10): [m(10)][100.0%][r=19.4MiB/s,w=8456KiB/s][r=4969,w=2114 IOPS][eta 00m:00s]
local_randrw_test: (groupid=0, jobs=10): err= 0: pid=11189: Mon Oct 25 11:01:46 2021
   read: IOPS=5230, BW=20.4MiB/s (21.4MB/s)(1226MiB/60031msec)
    slat (usec): min=2, max=342637, avg=1266.82, stdev=7241.29
    clat (usec): min=4, max=459544, avg=20056.81, stdev=24888.90
     lat (usec): min=134, max=459586, avg=21329.16, stdev=25378.16
    clat percentiles (usec):
     |  1.00th=[  1467],  5.00th=[  1844], 10.00th=[  2147], 20.00th=[  2606],
     | 30.00th=[  3032], 40.00th=[  3556], 50.00th=[  4359], 60.00th=[  6063],
     | 70.00th=[ 36439], 80.00th=[ 46924], 90.00th=[ 51643], 95.00th=[ 59507],
     | 99.00th=[105382], 99.50th=[117965], 99.90th=[137364], 99.95th=[152044],
     | 99.99th=[219153]
   bw (  KiB/s): min=  795, max= 4494, per=9.91%, avg=2072.23, stdev=744.04, samples=1195
   iops        : min=  198, max= 1123, avg=517.74, stdev=186.00, samples=1195
  write: IOPS=2243, BW=8972KiB/s (9188kB/s)(526MiB/60031msec)
    slat (usec): min=2, max=311932, avg=1272.76, stdev=7272.09
    clat (usec): min=6, max=458031, avg=20206.30, stdev=24897.71
     lat (usec): min=974, max=459755, avg=21484.12, stdev=25400.41
    clat percentiles (usec):
     |  1.00th=[  1500],  5.00th=[  1860], 10.00th=[  2147], 20.00th=[  2606],
     | 30.00th=[  3064], 40.00th=[  3621], 50.00th=[  4424], 60.00th=[  6194],
     | 70.00th=[ 36439], 80.00th=[ 46924], 90.00th=[ 51643], 95.00th=[ 59507],
     | 99.00th=[105382], 99.50th=[117965], 99.90th=[137364], 99.95th=[149947],
     | 99.99th=[200279]
   bw (  KiB/s): min=  357, max= 1944, per=9.90%, avg=888.57, stdev=325.49, samples=1195
   iops        : min=   89, max=  486, avg=221.80, stdev=81.37, samples=1195
  lat (usec)   : 10=0.01%, 50=0.01%, 100=0.01%, 250=0.02%, 500=0.01%
  lat (usec)   : 750=0.01%, 1000=0.01%
  lat (msec)   : 2=7.45%, 4=38.36%, 10=18.10%, 20=1.09%, 50=22.31%
  lat (msec)   : 100=11.42%, 250=1.24%, 500=0.01%
  cpu          : usr=0.26%, sys=19.41%, ctx=12026, majf=0, minf=18
  IO depths    : 1=0.1%, 2=0.1%, 4=0.1%, 8=0.1%, 16=100.0%, 32=0.0%, >=64=0.0%
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.1%, 32=0.0%, 64=0.0%, >=64=0.0%
     issued rwts: total=313975,134655,0,0 short=0,0,0,0 dropped=0,0,0,0
     latency   : target=0, window=0, percentile=100.00%, depth=16

Run status group 0 (all jobs):
   READ: bw=20.4MiB/s (21.4MB/s), 20.4MiB/s-20.4MiB/s (21.4MB/s-21.4MB/s), io=1226MiB (1286MB), run=60031-60031msec
  WRITE: bw=8972KiB/s (9188kB/s), 8972KiB/s-8972KiB/s (9188kB/s-9188kB/s), io=526MiB (552MB), run=60031-60031msec

Disk stats (read/write):
  sdb: ios=314008/134653, merge=0/0, ticks=189470/89778, in_queue=279286, util=99.75%

输出报告分析

下面是每个执行的数据方向的I/O统计数据信息的代表值含义

• read/write： 读/写的IO操作（还有一个trim没用过）
  • salt： 提交延迟，这是提交I/O所花费的时间（min:最小值，max:最大值，avg:平均值，stdev:标准偏差）
  • chat： 完成延迟，表示从提交到完成I/O部分的时间
  • lat： 相应时间，表示从fio创建I/O单元到完成I/O操作的时间
  • bw： 带宽统计
  • iops： IOPS统计
• lat(nsec/usec/msec)： I/O完成延迟的分布。这是从I/O离开fio到它完成的时间。与上面单独的读/写/修剪部分不同，这里和其余部分的数据适用于报告组的所有I/ o。10=0.01%意味着0.01%的I/O在250us以下完成。250=0.02%意味着0.02%的I/O需要10到250us才能完成。
• cpu： cpu使用率
• IO depths： I/O深度在作业生命周期中的分布
  • IO submit： 在一个提交调用中提交了多少个I/O。每一个分录表示该数额及其以下，直到上一分录为止——例如，4=100%意味着我们每次提交0到4个I/O调用
  • IO complete： 和上边的submit一样，不过这个是完成了多少个
  • IO issued rwt： 发出的read/write/trim请求的数量，以及其中有多少请求被缩短或删除
  • IO latency： 满足指定延迟目标所需的I/O深度

下面是Run status group 0 (all jobs) 全部任务汇总信息的代表值含义：

• bw： 总带宽以及最小和最大带宽
• io： 该组中所有线程执行的累计I/O
• run： 这组线程中最小和最长的运行时。

最后是Linux中特有的磁盘状态统计信息的代表值含义：

• ios： 所有组的I/ o个数
• merge： I/O调度器执行的总合并数
• ticks： 使磁盘繁忙的滴答数（仅供参考，原文是Number of ticks we kept the disk busy）
• in_queue： 在磁盘队列中花费的总时间
• util： 磁盘利用率。值为100%意味着我们保留了磁盘，如果一直很忙，那么50%的时间磁盘就会闲置一半的时间

FIO通过配置文件运行

除了命令行直接执行命令外，也可以通过写配置到xxx.fio文件中，每次只用修改配置即可，使用更方便些，执行方式为fio xxx.fio

[root@localhost jobs]# cat test.fio
[global]
filename=/dev/sdb
ioengine=libaio
direct=1
thread
group_reporting

[randread-4k-128M]
rw=randread
bs=4k
size=128M
numjobs=5

[randwrite-4k-128M]
rw=randwrite
bs=4k
size=128M
numjobs=5

[write-4k-128M]
rw=write
bs=4k
size=128M
numjobs=5

#执行fio命令测试
[root@localhost jobs]# fio test.fio
randread-4k-128M: (g=0): rw=randread, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=libaio, iodepth=1
...
randwrite-4k-128M: (g=0): rw=randwrite, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=libaio, iodepth=1
...
write-4k-128M: (g=0): rw=write, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=libaio, iodepth=1
...
fio-3.10
Starting 15 threads
Jobs: 6 (f=6): [_(3),r(1),_(1),w(5),E(1),_(4)][92.1%][r=10.8MiB/s,w=29.2MiB/s][r=2777,w=7483 IOPS][eta 00m:05s]
..........................

End……