FIO压测-SSDvsHDD

文章目录

1.FIO命令使用
2.FIO命令使用例子
3.IO队列深度
4.FIO配置文件使用
5.FIO区分SSD和HDD

1.FIO命令使用

目前主流的第三方IO测试工具有fio、iometer和Orion，这三种工具各有千秋。

fio在Linux系统下使用比较方便，iometer在window系统下使用比较方便，Orion是oracle的IO测试软件，可在没有安装oracle数据库的情况下模拟oracle数据库场景的读写。

fio -filename=<测试文件或块设备> -ioengine=sync -direct=1 -rw=randread -bs=8k
-size=1G -numjobs=8 -runtime=10-group_reporting -name=fio_test

参数

filename
待测试的文件或块设备。
若为文件，则代表测试文件系统的性能；例：-filename=/work/fstest/fio.img
若为块设备，则代表测试裸设备的性能; 例：-filename=/dev/sdb1
ioengine
采用的文件读写方式
（1）sync：采用read，write，使用fseek定位读写位置。
（2）psync：采用pread、pwrite进行文件读写操作
（3）vsync：采用readv(2) orwritev(2)进行文件读写操作，
注：read()和write()系统调用每次在文件和进程的地址空间之间传送一块连续的数据。但是，有时也需要将分散在内存多处地方的数据连续写到文件中，或者反之。在这种情况下，如果要从文件中读一片连续的数据至进程的不同区域，使用read()则要么一次将它们读至一个较大的缓冲区中，然后将它们分成若干部分复制到不同的区域，要么调用read()若干次分批将它们读至不同区域。同样，如果想将程序中不同区域的数据块连续地写至文件，也必须进行类似的处理。
UNIX提供了另外两个函数—readv()和writev()，它们只需一次系统调用就可以实现在文件和进程的多个缓冲区之间传送数据，免除了多次系统调用或复制数据的开销。
readv()称为散布读，即将文件中若干连续的数据块读入内存分散的缓冲区中。writev()称为聚集写，即收集内存中分散的若干缓冲区中的数据写至文件的连续区域中。
（4）libaio：Linux异步读写IO(Linuxnative asynchronous I/O)
libaio：Linux本地异步I/O。请注意，Linux可能只支持具有非缓冲I/O的排队行为（设置为“direct=1”或“buffered=0”）；rbd:通过librbd直接访问CEPH Rados
（5） posixaio: glibc POSIX 异步IO读写，使用aio_read(3)and aio_write(3)实现IO读写。
（6）mmap: File is memory mappedwith mmap(2) and data copied using memcpy(3).
（7）splice： splice(2) isused to transfer the data and vmsplice(2) to transfer data from user-space tothe kernel.
（8）syslet-rw： Use thesyslet system calls to make regular read/write asynchronous.
sg：SCSI genericsg v3 I/O.
（9）net ： Transferover the network. filename must be set appropriately to `host/port’ regardlessof data direction. If receiving,only the port argument is used.
（10）netsplice： Like net,but uses splice(2) and vmsplice(2) to map data and send/receive.
（11）Guasi : The GUASI I/Oengine is the Generic Userspace Asynchronous Syscall Interface approach to asycnronous I/O.
direct
当前测试是否采用直接IO方式进行读写，如果采用直接IO，则取值-direct=1，否则取值-direct=0。
采用直接IO写测试，会使得测试结果更加真实。
是否使用directIO，测试过程绕过OS自带的buffer，使测试磁盘的结果更真实。Linux读写的时候，内核维护了缓存，数据先写到缓存，后面再后台写到SSD。读的时候也优先读缓存里的数据。这样速度可以加快，但是一旦掉电缓存里的数据就没了。所以有一种模式叫做DirectIO，跳过缓存，直接读写SSD.
rw
读写模式。
（1）read：顺序读测试，使用方式-rw=read
（2）write：顺序写测试，使用方式-rw=write
（3）randread：随机读测试，使用方式-rw=randread
（4）randwrite：随机写测试，使用方式-rw=randwrite
（5）randrw：随机读写，-rw=randrw；默认比率为5:5，通过参数-rwmixread设定读的比率，如-rw=randrw-rwmixread=70，说明读写比率为70:30。

磁盘读写常用测试点：
1. Read=100% Ramdon=100% rw=randread (100%随机读)
2. Read=100% Sequence=100% rw=read （100%顺序读）
3. Write=100% Sequence=100% rw=write （100%顺序写）
4. Write=100% Ramdon=100% rw=randwrite （100%随机写）
5. Read=70% Sequence=100% rw=rw, rwmixread=70, rwmixwrite=30
（70%顺序读，30%顺序写）
6. Read=70% Ramdon=100% rw=randrw, rwmixread=70, rwmixwrite=30
(70%随机读，30%随机写)

bs
单次IO的块文件大小；例：-bs=4k
bssplit
设备读写访问的IO大小，例：-bssplit=4k/30:8k/40:16k/30，随机读4k文件占30%、8k占40%、16k占30%
bsrange
设置IO的块文件大小的范围，例如-bsrange=512-2048
size
本次测试文件的大小；例-size=1G
iodepth
IO队列深入，即一次下发的IO的个数，例如：-iodepth=16
队列的深度为16，在异步模式下，CPU不能一直无限的发命令到SSD。
比如SSD执行读写如果发生了卡顿，那有可能系统会一直不停的发命令，几千个，甚至几万个，这样一方面SSD扛不住，另一方面这么多命令会很占内存，系统也要挂掉了。这样，就带来一个参数叫做队列深度
numjobs
每个job（任务）开1个线程，这里用了几，后面每个用-name指定的任务就开几个线程测试。所以最终线程数=任务数（几个name=jobx）* numjobs。
sync
设置同步模式，同步-sync=1，异步-sync=0
fsync
设置数据同步模式，同步-fsync=1，异步-fsync=0
runtime
设置测试运行的时间，单位秒，例：-runtime=300
runtime=1000 测试时间为1000秒，如果不写则一直将5g文件分4k每次写完为止
group_reporting
关于显示结果的，汇总每个进程的信息
lockmem
对测试所使用的内存进行限制，如-lockmem=1g，限制1G
name
name=job1：一个任务的名字，重复了也没关系。如果fio -name=job1 -name=job2，建立了两个任务，共享-name=job1之前的参数。-name之后的就是job2任务独有的参数。
thread
使用pthread_create创建线程，另一种是fork创建进程。进程的开销比线程要大，一般都采用thread测试。
Block Devices（RBD）
无需使用内核RBD驱动程序（rbd.ko）。该参数包含很多ioengine，如：libhdfs/rdma等
group_reporting
关于显示结果的，汇总每个进程的信息
zero_buffers
用0初始化系统buffer
nrfiles
每个进程生成文件的数量

2.FIO命令使用例子

fio例子1

[root@rac01-node02]# fio -filename=/dev/sdc4 -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=randrw_70read_4k_local
randrw_70read_4k_local: (g=0): rw=randrw, bs=4K-4K/4K-4K/4K-4K, ioengine=psync, iodepth=1
...
fio-2.1.10
Starting 50 threads
Jobs: 21 (f=21): [____m____m_m___m____mmm__mmm__mm_m_mmm_m__m__m_m_m] [3.4% done] [7004KB/2768KB/0KB /s] [1751/692/0 iops] [eta 01h:27m:00s]
randrw_70read_4k_local: (groupid=0, jobs=50): err= 0: pid=13710: Wed May 31 10:23:31 2017
关键参数------  read : io=1394.2MB, bw=7926.4KB/s, iops=1981, runt=180113msecclat (usec): min=39, max=567873, avg=24323.79, stdev=25645.98lat (usec): min=39, max=567874, avg=24324.23, stdev=25645.98clat percentiles (msec):|  1.00th=[    3],  5.00th=[    5], 10.00th=[    6], 20.00th=[    7],| 30.00th=[    9], 40.00th=[   12], 50.00th=[   16], 60.00th=[   21],| 70.00th=[   27], 80.00th=[   38], 90.00th=[   56], 95.00th=[   75],| 99.00th=[  124], 99.50th=[  147], 99.90th=[  208], 99.95th=[  235],| 99.99th=[  314]bw (KB  /s): min=   15, max=  537, per=2.00%, avg=158.68, stdev=38.08write: io=615280KB, bw=3416.8KB/s, iops=854, runt=180113msecclat (usec): min=167, max=162537, avg=2054.79, stdev=7665.24lat (usec): min=167, max=162537, avg=2055.38, stdev=7665.23clat percentiles (usec):|  1.00th=[  201],  5.00th=[  227], 10.00th=[  249], 20.00th=[  378],| 30.00th=[  548], 40.00th=[  692], 50.00th=[  844], 60.00th=[  996],| 70.00th=[ 1160], 80.00th=[ 1304], 90.00th=[ 1720], 95.00th=[ 3856],| 99.00th=[40192], 99.50th=[58624], 99.90th=[98816], 99.95th=[123392],| 99.99th=[148480]bw (KB  /s): min=    6, max=  251, per=2.00%, avg=68.16, stdev=29.18lat (usec) : 50=0.01%, 100=0.03%, 250=3.15%, 500=5.00%, 750=5.09%lat (usec) : 1000=4.87%lat (msec) : 2=9.64%, 4=4.06%, 10=21.42%, 20=18.08%, 50=19.91%lat (msec) : 100=7.24%, 250=1.47%, 500=0.03%, 750=0.01%cpu          : usr=0.07%, sys=0.21%, ctx=522490, majf=0, minf=7IO depths    : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.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.0%, 32=0.0%, 64=0.0%, >=64=0.0%issued    : total=r=356911/w=153820/d=0, short=r=0/w=0/d=0latency   : target=0, window=0, percentile=100.00%, depth=1Run status group 0 (all jobs):READ: io=1394.2MB, aggrb=7926KB/s, minb=7926KB/s, maxb=7926KB/s, mint=180113msec, maxt=180113msecWRITE: io=615280KB, aggrb=3416KB/s, minb=3416KB/s, maxb=3416KB/s, mint=180113msec, maxt=180113msecDisk stats (read/write):sdc: ios=356874/153927, merge=0/10, ticks=8668598/310288, in_queue=8978582, util=99.99%

结果分析：

io=执行了多少M的IO
bw=平均IO带宽，即吞吐量，需重点关注
iops=IOPS，需重点关注
runt=线程运行时间
slat=提交延迟
clat=完成延迟
lat=响应时间
cpu=利用率
IO depths=io队列
IO submit=单个IO提交要提交的IO数
IO complete=Like the above submit number, but for completions instead.
IO issued=The number of read/write requests issued, and how many of them were short.
IO latencies=IO完延迟的分布
io=总共执行了多少size的IO
aggrb=group总带宽
minb=最小平均带宽.
maxb=最大平均带宽.
mint=group中线程的最短运行时间.
maxt=group中线程的最长运行时间.
ios=所有group总共执行的IO数.
merge=总共发生的IO合并数.
ticks=Number of ticks we kept the disk busy.
io_queue=花费在队列上的总共时间.
util=磁盘利用率

常用测试场景如下：

100%随机，100%读， 4K
fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=randread -ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=rand_100read_4k100%随机，100%写， 4K
fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=rand_100write_4k100%顺序，100%读 ，4K
fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=sqe_100read_4k100%顺序，100%写 ，4K
fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=sqe_100write_4k100%随机，70%读，30%写 4K
fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=randrw_70read_4k

3.IO队列深度

在某个时刻,有N个inflight的IO请求,包括在队列中的IO请求、磁盘正在处理的IO请求。N就是队列深度。

加大硬盘队列深度就是让硬盘不断工作，减少硬盘的空闲时间。
加大队列深度 -> 提高利用率 -> 获得IOPS和MBPS峰值 ->注意响应时间在可接受的范围内，
增加队列深度的办法有很多，使用异步IO，同时发起多个IO请求，相当于队列中有多个IO请求，多线程发起同步IO请求，相当于队列中有多个IO请求。
增大应用IO大小，到达底层之后，会变成多个IO请求，相当于队列中有多个IO请求队列深度增加了。
队列深度增加了，IO在队列的等待时间也会增加，导致IO响应时间变大，这需要权衡。

为何要对磁盘I/O进行并行处理呢？

主要目的是提升应用程序的性能。这一点对于多物理磁盘组成的虚拟磁盘（或LUN）显得尤为重要。
如果一次提交一个I/O，虽然响应时间较短，但系统的吞吐量很小。
相比较而言，一次提交多个I/O既缩短了磁头移动距离（通过电梯算法），同时也能够提升IOPS。
假如一部电梯一次只能搭乘一人，那么每个人一但乘上电梯，就能快速达到目的地（响应时间），但需要耗费较长的等待时间（队列长度）。
因此一次向磁盘系统提交多个I/O能够平衡吞吐量和整体响应时间。

Linux系统查看默认队列深度：

[root@qsdb ~]# lsscsi -l
[0:0:0:0]    disk    DGC      VRAID            0533  /dev/sda state=running queue_depth=30 scsi_level=5 type=0 device_blocked=0 timeout=30使用dd命令设置bs=2M进行测试：
dd if=/dev/zero of=/dev/sdd bs=2M count=1000 oflag=direct记录了1000+0 的读入 记录了1000+0 的写出 2097152000字节(2.1 GB)已复制，10.6663 秒，197 MB/秒
Device: rrqm/s   wrqm/s   r/s   w/s   rsec/s   wsec/s   avgrq-sz   avgqu-sz   await   svctm   %util
sdd      0.00     0.00   0.00  380.60  0.00    389734.40  1024.00  2.39       6.28    2.56    97.42结果：
可以看到2MB的IO到达底层之后，会变成多个512KB的IO，平均队列长度为2.39，这个硬盘的利用率是97%，MBPS达到了197MB/s。

4.FIO配置文件使用

方式1：

xxx.fio

fio xxx.fio(脚本文件)脚本基本格式
; -- start job file --';'或'#'为fio脚本注释
[global] ;[global]为全局参数，即后面所有job都可以共享
rw=randread
size=${SIZE}
numjobs=${NUMJOBS}
; -- end job file --在调用时赋值对应变量参数
SIZE=64m NUMJOBS=4 fio jobfile.fio

方式2：多个job同时配置，直接执行也可以选择job执行

job.conf

[global]
direct=1
ioengine=libaio
iodepth=2
runtime=10
time_based
group_reporting[read_4K];[job name]对应job 名，后面加该job特有参数
filename=/dev/sda
rw=read
bs=4K
size=1G
numjobs=8[write_4K]
filename=/dev/sde
rw=write
bs=4K
size=1G
numjobs=16执行所有job：fio job.conf
执行单个jbob：fio job.cfg --section read_4K

5.FIO区分SSD和HDD

由探索fio参数如何选择以及全方位对比HDD和SSD性能博主提供的经验，脚本fio.conf参数如下：
通过随机写或者随机读即可区分

[global]
ioengine=libaio      # 异步IO
direct=1             # 排除OS的IO缓存机制的影响
size=1g              # 每个fio进程/线程的最大读写
lockmem=1G           # 锁定所使用的内存大小
iodepth=1            # 队列深度1
numjobs=1            # 同时开启的fio进程/线程数为1
bs=4k
runtime=30
numjobs=8 [4K_randread]
filename=/dev/${DEVNAME}
rw=randread[4K_randwrite]
filename=/dev/${DEVNAME}
rw=randwrite[4K_randrw]
filename=/dev/${DEVNAME}
rw=randrw        ##默认比例5:5，可调运行方法：DEVNAME=sdw fio fio.conf --section 4K_randread
对比IOPS以及BW参数即可

参考：FIO – IO压力测试工具，linux FIO命令详解(一)：磁盘IO测试工具 fio (并简要介绍iostat工具)，IO测试工具之fio详解，探索fio参数如何选择以及全方位对比HDD和SSD性能，FIO使用详解

FIO压测-SSDvsHDD相关推荐

Fio压测工具和io队列深度理解和误区
Fio 是个强大的IO压力测试工具,我之前写过不少fio的使用和实践,参见这里. 随着块设备的发展,特别是SSD盘的出现,设备的并行度越来越高.利用好这些设备,有个诀窍就是提高设备的iodepth, ...
fio压测磁盘读写性能
FIO是测试IOPS的非常好的工具,用来对磁盘进行性能测试和验证.磁盘IO是检查磁盘性能的重要指标,可以按照负载情况分成照顺序读写,随机读写两大类. 1.测试用文件 [global] ioengine ...
Fio工具详解【强大的IO性能压测工具】
文章目录 Fio压测工具操作常用参数 [time] [I/O tpye] [Blocks size] [Job description] [Threads, processes and job sy ...
FIO 存储性能压测
一. FIO简介 FIO 是一个多线程IO生成工具,可以生成多种IO模式(随机.顺序.读.写四大类),用来测试磁盘设备的性能.GFIO是FIO的图形监测工具,它提供了图形界面的参数配置,和性能监测图像 ...
20天持续压测，告诉你云存储性能哪家更强？
2019独角兽企业重金招聘Python工程师标准>>> 上个月,笔者对国内两大云厂商(阿里云和腾讯云)的云服务器.云数据库和云存储三种产品做了性能评测,算是对两家的部分计算和存储产品 ...
压测瓶颈在mysql_MySQL的性能基线收集及压力测试
建立基线的作用: 计算机科学中,基线是项目储存库中每个工件版本在特定时期的一个"快照". 比如我们现在有并发事物,那么在某时刻发起一个事物会产生当前数据的快照,那么这个快照就相当理 ...
多种系统负载100%方法(高可用测试、性能压测用)
文章目录 1.高可用压测 1.1.CPU使用率100% 1.2.内存使用率100%,发生swap 1.3.IO资源压测 1.4.进程数达到上限 1.5.网络负载接近100% 2.性能压测 2.1.CP ...
Centos 异步 IO framework io_uring,基本原理,程序示例与性能压测
尊重原创版权: https://www.conghengx.com/hot/37285.html 更多内容参考: https://www.conghengx.com/ Linux 异步 I/O 框架 ...
MySQL性能指标TPS+QPS+IOPS压测
1.前言今天主要介绍MySQL数据库,或者说所有数据库的三个关键性能指标TPS\QPS\IOPS 2.性能指标概览 QPS(Queries Per Second): 就是每秒的查询数,对数据库而言就 ...
centos6.10和centos7.6 系统性能压测数据
一.环境说明 1.硬件 CPU:Intel(R) Xeon(R) E5-2630 v4 @ 2.20GHz 40核内存:192G(12*16G)DDR4 硬盘:6*1.2T (SAS,10K RPM ...

FIO压测-SSDvsHDD

文章目录

1.FIO命令使用

2.FIO命令使用例子

3.IO队列深度

4.FIO配置文件使用

5.FIO区分SSD和HDD

FIO压测-SSDvsHDD相关推荐

最新文章

热门文章