手机版
你好,游客 登录 注册 搜索
背景:
阅读新闻

Linux中使用FIO测试磁盘的iops

[日期:2017-04-29] 来源:Linux社区  作者:Linux [字体: ]

FIO是测试IOPS的非常好的工具,用来对硬件进行压力测试和验证,支持13种不同的I/O引擎,包括:sync,mmap, libaio, posixaio, SG v3, splice, null, network, syslet, guasi, solarisaio 等等。
fio 官网地址:http://freshmeat.net/projects/fio/

一,FIO安装
wget http://brick.kernel.dk/snaps/fio-2.2.5.tar.gz

yum install libaio-devel
tar -zxvf fio-2.2.5.tar.gz
cd fio-2.2.5
make
make install

二,FIO用法:

随机读:(可直接用,向磁盘写一个2G文件,10线程,随机读1分钟,给出结果)
fio -filename=/tmp/test_randread -direct=1 -iodepth 1 -thread -rw=randread -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest

说明:
filename=/dev/sdb1      测试文件名称,通常选择需要测试的盘的data目录。
direct=1                测试过程绕过机器自带的buffer。使测试结果更真实。
rw=randwrite            测试随机写的I/O
rw=randrw                测试随机写和读的I/O
bs=16k                  单次io的块文件大小为16k
bsrange=512-2048        同上,提定数据块的大小范围
size=5g    本次的测试文件大小为5g,以每次4k的io进行测试。
numjobs=30              本次的测试线程为30.
runtime=1000            测试时间为1000秒,如果不写则一直将5g文件分4k每次写完为止。
ioengine=psync          io引擎使用pync方式
rwmixwrite=30            在混合读写的模式下,写占30%
group_reporting          关于显示结果的,汇总每个进程的信息。

此外
lockmem=1g              只使用1g内存进行测试。
zero_buffers            用0初始化系统buffer。
nrfiles=8                每个进程生成文件的数量。

 

 

read 顺序读

write 顺序写

rw,readwrite 顺序混合读写

 

randwrite 随机写

randread 随机读

randrw 随机混合读写

 

 

io总的输入输出量

bw:带宽  KB/s

iops:每秒钟的IO数

runt:总运行时间

lat (msec):延迟(毫秒)

msec: 毫秒

 

usec: 微秒

 

 

 

顺序读:
fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest

随机写:
fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest

顺序写:
fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest

混合随机读写:
fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest -ioscheduler=noop

 

三,实际测试范例:

[root@localhost ~]# fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -ioengine=psync -bs=16k -size=200G -numjobs=30 -runtime=100 -group_reporting -name=mytest1
mytest1: (g=0): rw=randrw, bs=16K-16K/16K-16K, ioengine=psync, iodepth=1

mytest1: (g=0): rw=randrw, bs=16K-16K/16K-16K, ioengine=psync, iodepth=1
fio 2.0.7
Starting 30 threads
Jobs: 1 (f=1): [________________m_____________] [3.5% done] [6935K/3116K /s] [423 /190  iops] [eta 48m:20s] s]             
mytest1: (groupid=0, jobs=30): err= 0: pid=23802
  read : io=1853.4MB, bw=18967KB/s, iops=1185 , runt=100058msec
    clat (usec): min=60 , max=871116 , avg=25227.91, stdev=31653.46
    lat (usec): min=60 , max=871117 , avg=25228.08, stdev=31653.46
    clat percentiles (msec):
    |  1.00th=[    3],  5.00th=[    5], 10.00th=[    6], 20.00th=[    8],
    | 30.00th=[  10], 40.00th=[  12], 50.00th=[  15], 60.00th=[  19],
    | 70.00th=[  26], 80.00th=[  37], 90.00th=[  57], 95.00th=[  79],
    | 99.00th=[  151], 99.50th=[  202], 99.90th=[  338], 99.95th=[  383],
    | 99.99th=[  523]
    bw (KB/s)  : min=  26, max= 1944, per=3.36%, avg=636.84, stdev=189.15
  write: io=803600KB, bw=8031.4KB/s, iops=501 , runt=100058msec
    clat (usec): min=52 , max=9302 , avg=146.25, stdev=299.17
    lat (usec): min=52 , max=9303 , avg=147.19, stdev=299.17
    clat percentiles (usec):
    |  1.00th=[  62],  5.00th=[  65], 10.00th=[  68], 20.00th=[  74],
    | 30.00th=[  84], 40.00th=[  87], 50.00th=[  89], 60.00th=[  90],
    | 70.00th=[  92], 80.00th=[  97], 90.00th=[  120], 95.00th=[  370],
    | 99.00th=[ 1688], 99.50th=[ 2128], 99.90th=[ 3088], 99.95th=[ 3696],
    | 99.99th=[ 5216]
    bw (KB/s)  : min=  20, max= 1117, per=3.37%, avg=270.27, stdev=133.27
    lat (usec) : 100=24.32%, 250=3.83%, 500=0.33%, 750=0.28%, 1000=0.27%
    lat (msec) : 2=0.64%, 4=3.08%, 10=20.67%, 20=19.90%, 50=17.91%
    lat (msec) : 100=6.87%, 250=1.70%, 500=0.19%, 750=0.01%, 1000=0.01%
  cpu          : usr=1.70%, sys=2.41%, ctx=5237835, majf=0, minf=6344162
  IO 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=118612/w=50225/d=0, short=r=0/w=0/d=0

Run status group 0 (all jobs):
  READ: io=1853.4MB, aggrb=18966KB/s, minb=18966KB/s, maxb=18966KB/s, mint=100058msec, maxt=100058msec
  WRITE: io=803600KB, aggrb=8031KB/s, minb=8031KB/s, maxb=8031KB/s, mint=100058msec, maxt=100058msec

Disk stats (read/write):
  sdb: ios=118610/50224, merge=0/0, ticks=2991317/6860, in_queue=2998169, util=99.77%

主要查看以上红色字体部分的iops

 

 

 

 

这个文档是对fio-2.0.9 HOWTO文档的翻译,fio的参数太多了,翻译这个文档时并没有测试每一个参数的功能和使用方法,只有少量参数做了试验,大部分的参数采用的是根据字面翻译或是个人理解的翻译,必然有些出入,先发出来,以后有使用的时候再被充和修改。在另一个文档中会对fio自带的实例进行分析,可能会更为清晰一些。

 fio这个工具实在太强大了,列举一下他的NB之处吧

 1)支持十几种存储引擎,可以自定义

 2)自带做图工具,调用gnuplot做图

 3)支持几乎所有的存储描述参数

 4)大量对CPU,内存,进程/线程,文件,IO特性的配置

 5)压缩,trace回放,。。。这些都包含,灵活的配置

简介

fio最初是用来节省为特定负载写专门测试程序,或是进行性能测试,或是找到和重现bug的时间。写这么一个测试应用是非常浪费时间的。因此需要一个工具来模拟给定的io负载,而不用重复的写一个又一个的特定的测试程序。但是test负载很难定义。因为可能会产生很多进程或线程,他们每一个都用他们自己的方式产生io。fio需要足够灵活得来模拟这些case。

典型的fio的工作过程

1)写一个job文件来描述要访真的io负载。一个job文件可以控制产生任意数目的线程和文件。典型的job文件有一个global段(定义共享参数),一个或多少job段(描述具体要产生的job)。

2)运行时,fio从文件读这些参数,做处理,并根据这些参数描述,启动这些访真线程/进程

运行fio

运行方式:

$fio job_file

它会根据job_file的内容来运行。你可以在命令行中指定多个job file,fio进串行化运行这些文件。相当于在同一个job file不同的section之间使用了stonewall参数。

如果某个job file只包含一个job,可以在命令行中给出参数,来直接运行,不再需要读取job file。命令行参数同job file参数的格式是一样的。比如,在job file中的参数iodepth=2,在命令行中可以写为–iodepth 2 或是 –iodepth=2.

fio不需要使用root来支行,除非使用到的文件或是设备需要root权限。一些选项可能会被限制,比如内存锁,io调度器切换,或是nice value降级。

 

job文件格式

job file格式采用经典的ini文件,[]中的值表示job name,可以采用任意的ASCII字符,‘global’除外,global有特殊的意义。Global section描述了job file中各个job的默认配置值。一个job section可以覆盖global section中的参数,一个job file可以包含几个global section.一个job只会受到它上面的global section的影响。‘;’和‘#’可以用作注释

两个进程,分别从一个从128MB文件中,随机读的job file.

;–start job file–

[global]

rw=randread

size=128m

 

[job1]

 

[job2]

;–end job file–

job1和job2 section是空的,因为所有的描述参数是共享的。没有给出filename=选项,fio会为每一个job创建一个文件名,如果用命令写,则是:

$fio –name=global –rw=randread –size=128m –name=job1 –name=job2

 

多个进程随机写文件的实例

;–start job file —

[random-writers]

ioengine=libaio

iodepth=4

rw=randwrite

bs=32k

direct=0

size=64m

numjobs=4

;–end job file–

 

没有global section,只有一个job section.

上一个实例的说明:采用async,每一个文件的队列长度为4,采用随机写,采用32k的块,采用非direct io,共有4个进程,每个进程随机写64M的文件。也可以采用下面的命令

$fio –name=random-writers –ioengine=libaio –iodepth=4 –rw=randwrite –bs=32k –direct=0 –size=64m –numjobs=4

 

环境变量

在job file中支持环境变量扩展。类似于${VARNAME}可以作为选项的值(在=号右边)。

实例:

$SIZE=64m  NUMJOBS=4 fio jobfile,fio

;–start job files–

[random-writers]

rw=randwrite

size=${SIZE}

numjobs=${NUMJOBS}

;–end job file–

 

将被扩展为

;–start job file–

[random-writers]

rw=randwrite

size=64m

numjobs=4

;–end job file–

 

保留keywords

fio有一些保留keywords,在内部将其替换成合适的值,这些keywords是:

$pagesize  当前系统的页大小

$mb_memory 系统的总内存的大小,以MB为单位

$ncpus 在线有效的cpu数

这引起在命令行中和job file中都可以用,当job运行的时候,会自动的用当前系统的徝进行替换。支持简单的数学计算,如:

size=8*$mb_memory

 

类型

str 字符串

time时间(int)

int 整数

bool

irange 整数范围

float_list 符点数列

 

一个job包含的基本的参数

1)IO类型

向文件发起的IO类型。

<1>readwrite=str,rw=str

read 顺序读

write 顺序写

randwrite 随机写

randread 随机读

rw,readwrite 顺序混合读写

randrw 随机混合读写

[参数备注]

对于混合io类型,混认是50%的读,50%的写,对于特定的io类型,因为速度可能不同,结果可能会有稍有偏差.

通过在在str之后加“:<nr>”可以配置在执行一下获取offset操作之前要执行的IO次数。For a random read, it would lik ‘rw=randread:8′ for passing in an offset modifier with a value of 8.如果后缀用于顺序IO类型的话,,那么将在每次IO之后,将这个值加到产生的offset之后。e.g. rw=write:4k每次写之后将会跳过4K。它将顺序的IO转化为带有洞的顺序IO。参考‘rw_sequencer’选项。

<2>rw_sequencer=str

如果rw=<str>后有offset修饰的话,这个选项可以控制这个数字<nr>如何修饰产生的IO offset.可以接收的值是:

sequential 产生顺序的offset

identical 产生相同的offset

[参数备注]

‘sequential’仅用于随机IO。通常情况下,fio在每次IO之后,将会生成一个新的随机IO。e.g.rw=randread:8,将会在每8次IO之后执行seek,而不是每次IO之后。顺序IO已经是顺序的,再设置为‘sequential’将不会产生任何不同。‘identical’会产生同‘sequential’相似的行为,只是它会连续产生8次相同的offset,然后生成一个新的offset.

2)block size

产生的IO单元的大小,可以是一个孤立的值,也可以是一个范围。

<1>blocksize=int,bs=int

单次IO的block size,默认为4k。如果是单个值的话,将会对读写都生效。如果是一个逗号,再跟一个int值的话,则是仅对于写有效。也就是说,格式可以是bs=read_end_write或是bs=read,write。e.g. bs=4k,8k读使用4k的块,写使用8k的块。e.g.bs=,8k将使得写采用8k的块,读采用默认的值。

3)IO size

将会读/写多少数据

<1>size=int

这个job IO总共要传输的数据的大小。FIO将会执行到所有的数据传输完成,除非设定了运行时间(‘runtime’选项)。除非有特定的‘nrfiles’选项和‘filesize’选项被设置,fio将会在job定义的文件中平分这个大小。如果这个值不设置的话,fio将会使用这个文件或设备的总大小。如果这些文件不存在的话,size选项一定要给出。也可以给出一个1到100的百分比。e.g. size=20%,fio将会使用给定的文件或设备的20%的空间。

4)IO引擎

发起IO的方式。

<1>ioengine=str

定义job向文件发起IO的方式

sync 基本的read,write.lseek用来作定位

psync 基本的pread,pwrite

vsync 基本的readv,writev

libaio Linux专有的异步IO。Linux仅支持非buffered IO的队列行为。

posixaio glibc posix异步IO

solarisaio solaris独有的异步IO

windowsaio windows独有的异步IO

mmap 文件通过内存映射到用户空间,使用memcpy写入和读出数据

splice 使用splice和vmsplice在用户空间和内核之间传输数据

syslet-rw 使用syslet 系统调用来构造普通的read/write异步IO

sg SCSI generic sg v3 io.可以是使用SG_IO ioctl来同步,或是目标是一个sg字符设备,我们使用read和write执行异步IO

null 不传输任何数据,只是伪装成这样。主要用于训练使用fio,或是基本debug/test的目的。

net 根据给定的host:port通过网络传输数据。根据具体的协议,hostname,port,listen,filename这些选项将被用来说明建立哪种连接,协议选项将决定哪种协议被使用。

netsplice 像net,但是使用splic/vmsplice来映射数据和发送/接收数据。

cpuio 不传输任何的数据,但是要根据cpuload=和cpucycle=选项占用CPU周期.e.g. cpuload=85将使用job不做任何的实际IO,但要占用85%的CPU周期。在SMP机器上,使用numjobs=<no_of_cpu>来获取需要的CPU,因为cpuload仅会载入单个CPU,然后占用需要的比例。

guasi GUASI IO引擎是一般的用于异步IO的用户空间异步系统调用接口

rdma RDMA I/O引擎支持RDMA内存语义(RDMA_WRITE/RDMA_READ)和通道主义(Send/Recv)用于InfiniBand,RoCE和iWARP协议

external 指明要调用一个外部的IO引擎(二进制文件)。e.g. ioengine=external:/tmp/foo.o将载入/tmp下的foo.o这个IO引擎

5)IO depth

如果IO引擎是异步的,这个指定我们需要保持的队列深度

<1>iodepth=int

加于文件之上的保持的IO单元。默认对于每个文件来说是1,可以设置一个更大的值来提供并发度。iodepth大于1不会影响同步IO引擎(除非verify_async这个选项被设置)。even async engines may impose OS restrictions causing the desired depth not to be achieved.这会在Linux使用libaio并且设置direct=1的时候发生,因为buffered io在OS中不是异步的。在外部通过类似于iostat这些工具来观察队列深度来保证这个IO队列深度是我们想要的。这个可以参考褚霸的博客http://blog.yufeng.info/archives/2104

6)IO type

<1>direct=bool

true,则标明采用non-buffered io.同O_DIRECT效果一样。ZFS和Solaris不支持direct io,在windows同步IO引擎不支持direct io

<2>buffered=bool

true,则标明采用buffered io。是direct的反义词,默认是true

7)Num files

负载将分发到几个文件之中

<1>nrfiles=int

用于这个job的文件数目,默认为1

<2>openfiles=int

在同一时间可以同时打开的文件数目,默认同nrfiles相等,可以设置小一些,来限制同时打开的文件数目。

8)Num threads

<1>numjobs=int

创建特定数目的job副本。可能是创建大量的线程/进程来执行同一件事。我们将这样一系列的job,看作一个特定的group

详细参数:

<1>name=str

job名,用于输出信息用的名字。如果不设置的话,fio输出信息时将采用job name,如果设置的话,将用设置的名字。在命令行中,这个参数有特殊的作用,标明一个新job的开始。

<2>description=str

job的说明信息,在job运行的时候不起作用,只是在输出文件描述信息的时候才起作用。

<3>directory=str

使用的文件的路径前缀,默认是./

<4>filename=str

一般情况下,fio会根据job名,线程号,文件名来产生一个文件名。如果,想在多个job之间共享同一个文件的话,可以设定一个名字来代替默认的名字.如果ioengine是‘net’的话,文件名则是以这种格式=host,port,protocol.如果ioengine是基于文件的话,可以通过‘:’分割来设定一系列的文件。e.g. filename=/dev/sda:/dev/sdb 希望job打开/dev/sda和/dev/sdb作为两个工作文件。

<5>opendir=str

让fio递归的添加目录下和子目录下的所有文件。

<6>lockfile=str

fio在文件上执行IO之前默认是不锁文件的,这样的话,当有多个线程在此文件上执行IO的话,会造成结果的不一致。这个选项可以用来共享文件的负载,支持的锁类型:

none 默认不使用锁

exclusive 排它锁

readwrite 读写锁

在后面可以加一个数字后缀,如果设置的话,每一个线程将会执行这个数字指定的IO后才会放弃锁,因为锁的开销是比较大的,所以这种方式可以加速IO。

<7>kb_base=int

size换算单位,1000/1024,默认为1024

<8>randrepeat=bool

对于随机IO负载,配置生成器的种子,使得路径是可以预估的,使得每次重复执行生成的序列是一样的。

<9>use_os_rand=bool

fio可以使用操作系统的随机数产生器,也可以使用fio内部的随机数产生器(基于tausworthe),默认是采用fio内部的产生器,质量更数,速度更快。

<7>fallocate=str

如何准备测试文件

none 不执行预分配空间

posix 通过posix_fallocate()预分配空间

keep 通过fallocate()(设置FALLOC_FL_KEEP_SIZE)预分配空间

0 none的别名,出于兼容性

1 posix的别名,出于兼容性

并不是在所有的平台上都有效,‘keep’仅在linux上有效,ZFS不支持。默认为‘posix’

<8>fadvise_hint=bool

默认fio将使用fadvise()来告知内核fio要产生的IO类型,如果不想告诉kernel来执行一些特定的IO类型的话,可行关闭这个选项。如果设置的话,fio将使用POSIX_FADV_SEWUENTIAL来作顺序IO,使用POSIX_FADV_RANDOM来做随机IO

<9>filesize=int

单个文件的大小,可以是一个范围,在这种情况下,fio将会在一个范围内选择一个大小来决定单个文件大小,如果没有设置的话,所有的文件将会是同样的大小。

<10>fill_device=bool,fill_fs=bool

填满空间直到达到终止条件ENOSPC,只对顺序写有意义。对于读负载,首行要填满挂载点,然后再启动IO,对于裸设备结点,这个设置则没有什么意义,因为,它的大小已被被文件系统知道了,此外写的超出文件将不会返回ENOSPC.

<11>blockalign=int,ba=int

配置随机io的对齐边界。默认是与blocksize的配置一致,对于direct_io,最小为512b,因为它与依赖的硬件块大小,对于使用文件的随机map来说,这个选项不起作用。

<14>blocksize_range=irange,bsrange=irange

不再采用单一的块大小,而是定义一个范围,fio将采用混合io块大小.IO单元大小一般是给定最小值的备数。同时应用于读写,当然也可以通过‘,’来隔开分别配置读写。

<15>bssplit=str

可以更为精确的控制产生的block size.这个选项可以用来定义各个块大小所占的权重.格式是

bssplit=blocksize/percentage;blocksize/percentage

bssplit=4k/10:64k/50;32k/40

产生的这样的负载:50% 64k的块,10% 4k的块, 40% 32k的块

可以分别为读和写来设置

e.g. bssplit=2k/50:4k/50,4k/90:8k/10

产生这样的负载:读(50% 64k的块,50% 4k的块),写(90% 4k的块, 10% 8k的块)

<16>blocksize_unaligned,bs_unaligned

如果这个选项被设置的,在bsrange范围内的大小都可以产生,这个选项对于direct io没有作用,因为对于direct io至少需要扇区对齐

<17>zero_buffers

如果这个选项设置的话,IO buffer全部位将被初始为0,如果没有置位的话,将会是随机数.

<18>refill_buffers

如果这个选项设置的话,fio将在每次submit之后都会将重新填满IO buffer,默认都会在初始是填满,以后重复利用。这个选项只有在zero_buffers没有设置的话,这个选项才有作用。

<19>scramble_buffer=bool

如果refilee_buffers成本太高的话,但是负载要求不使用重复数据块,设置这个选项的话,可以轻微的改动IO buffer内容,这种方法骗不过聪明的块压缩算法,但是可以骗过一些简单的算法。

<20>buffer_compress_percentage=int

如果这个设置的话,fio将会尝试提供可以压缩到特定级别的Buffer内容。FIO是能完提供混合的0和随机数来实现的。Note that this is per block size unit, for file/disk wide compression level that matches this setting, you’ll also want to set refill_buffers.

<21>buffer_compress_chunk=int

See buffer_compress_percentage. This setting allows fio to manage how big the ranges of random data and zeroed data is. Without this set, fio will provide buffer_compress_percentage of blocksize random data, followed by the remaining zeroed. With this set to some chunk size smaller than the block size, fio can alternate random and zeroed data throughout the IO buffer.

<22>file_service_type=str

fio切换job时,如何选择文件,支持下面的选项

random 随机选择一个文件

roundrobin 循环使用打开的文件,默认

sequential 完成一个文件后,再移动到下一个文件

这个选项可以加后缀数字,标明切换到下一个新的频繁程度。

e.g. random:4 每4次IO后,将会切换到一下随机的文件

<23>iodepth_batch_submit=int,iodepth_batch=int

这个定义了一次性提交几个IO,默认是1,意味着一旦准备好就提交IO,这个选项可以用来一次性批量提交IO

<24>iodepth_batch_complete=int

这个选项定义了一次取回多少个IO,如果定义为1的话,意味着我们将向内核请求最小为1个IO.The IO retrieval will go on until we hit the limit set by iodetph_low.If this variable is set to 0, then fi will always check for completed events before quuing more IO.This helps reduce IO latency, at the cost of more retrieval sysstem calls.

<25>iodepth_low=int

这个水位标志标明什么时候开始重新填充这个队列,默认是同iodepth是一样的,意味着,每时每刻都在尝试填满这个队列。如果iodepth设置为16,而iodepth设置为4的话,那么fio将等到depth下降到4才开始重新填充

<26>offset=int

在文件特定的偏移开始读数据,在这个offset之前的数据将不会被使用,有效的文件大小=real_size-offset

<27>offset_increment=int

如果这个选项被设置的话,实际的offset=offset+offset_increment * thread_number,线程号是从0开始的一个计数器,对于每一个job来说是递增的。这个选项对于几个job同时并行在不交界的地方操作一个文件是有用的。

<28>fsync=int

如果写一个文件的话,每n次IO传输完block后,都会进行一次同步脏数据的操作。

e.g. fsync=int

fio每32次写之后,同步一次文件。如果采用non-buffered io,不需要使用sync同步文件

对于sg io引擎的话,可以在任何情况下同步磁盘cache.

<29>fdatasync=int

同fsync,但是采用fdatasync()来同步数据,但不同步元数据

<30>sync_file_range=str:val

对于每‘val’个写操作,将执行sync_file_range()。FIO将跟踪从上次sync_file_range()调用之扣的写范围,‘str’可以是以下的选择

wait_before SYNC_FILE_RANGE_WAIT_BEFORE

write SYNC_FILE_RANGE_WRITE

wait_after SYNC_FILE_RANGE_WAIT_AFTER

e.g.sync_file_range=wait_before,write:8,fio将在每8次写后使用SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE

更多详情见请继续阅读下一页的精彩内容http://www.linuxidc.com/Linux/2017-04/143255p2.htm

linux
相关资讯       fio  iops 
本文评论   查看全部评论 (0)
表情: 表情 姓名: 字数

       

评论声明
  • 尊重网上道德,遵守中华人民共和国的各项有关法律法规
  • 承担一切因您的行为而直接或间接导致的民事或刑事法律责任
  • 本站管理人员有权保留或删除其管辖留言中的任意内容
  • 本站有权在网站内转载或引用您的评论
  • 参与本评论即表明您已经阅读并接受上述条款