windows下使用fio性能测试工具参数怎么写？_百度知道
windows下使用fio性能测试工具参数怎么写？
fio --name=nimeimei --ioengine=windowsaio --filename=g:\file
--rw=write --direct=1 --size=1g --thread=1 iodepth=1 bs=4K
在cmd下执行此命令，总是提示：fopen job file:NO such file or directory
是我的filename路径那块写错了吗？具体该怎么写，...
估计是很少有人在windows使用这个工具，百度上都没有关于这块的介绍，只是在linux下使用FIO来测试。
我有更好的答案
供你参考:硬盘分区里文件拷贝的方式（个人发现结果不准，不知道原因）：fio --name=test --direct=1 --iodepth=32 --blocksize=1048576 --ioengine=windowsaio --thread=1 --size= --rw=read --filename=g:物理读写方式（目标硬盘不能有分区）：fio --name=test --direct=1 --iodepth=32 --blocksize=1048576 --ioengine=windowsaio --thread=1 --runtime=10 --rw=read --filename=\\.\physicaldrive1其中目标物理硬盘的名字用以下命令找到：&wmic diskdrive get name,model,size&
采纳率：100%
在最后2个选项前面加上--：fio --name=nimeimei --ioengine=windowsaio --filename=g:\file
--rw=write --direct=1 --size=1g --thread=1 --iodepth=1 --bs=4K
--filename=g\:\file“：”是需要转义的
--filename=\\.\PhysicalDrive1
--filename=g:\file为何是一个WINDOWS路径？不应该是这样的吗？--filename=/dev/file
大哥，我说的就是在windows下使用fio大哥，，windows下使用的，，在CMD命令行中执行fio命令。。。
其他2条回答
为您推荐：
其他类似问题
您可能关注的内容
性能测试的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。FIO是测试IOPS的非常好的工具，用来对硬件进行压力测试和验证，支持13种不同的I/O引擎，包括:sync,mmap, libaio, posixaio, SG v3, splice, null, network, syslet, guasi, solarisaio 等等。
fio 官网地址：
一，FIO安装
yum install libaio-devel
tar -zxvf fio-2.2.5.tar.gz
cd fio-2.2.5
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
Starting 30 threads
Jobs: 1 (f=1): [________________m_____________] [3.5% done] [K /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%, %
&&& 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%, %
& 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=24, merge=0/0, ticks=0, 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最初是用来节省为特定负载写专门测试程序，或是进行性能测试，或是找到和重现的时间。写这么一个测试应用是非常浪费时间的。因此需要一个工具来模拟给定的负载，而不用重复的写一个又一个的特定的测试程序。但是负载很难定义。因为可能会产生很多进程或线程，他们每一个都用他们自己的方式产生。需要足够灵活得来模拟这些。
典型的的工作过程
1）写一个文件来描述要访真的负载。一个文件可以控制产生任意数目的线程和文件。典型的文件有一个段（定义共享参数），一个或多少段（描述具体要产生的）。
2）运行时，从文件读这些参数，做处理，并根据这些参数描述，启动这些访真线程进程
运行方式：
$fio&job_file
它会根据的内容来运行。你可以在命令行中指定多个，进串行化运行这些文件。相当于在同一个不同的之间使用了参数。
如果某个只包含一个可以在命令行中给出参数，来直接运行，不再需要读取。命令行参数同参数的格式是一样的。比如，在中的参数，在命令行中可以写为或是&
fio不需要使用来支行，除非使用到的文件或是设备需要权限。一些选项可能会被限制，比如内存锁，调度器切换，或是降级。
job文件格式
job&file格式采用经典的文件，中的值表示，可以采用任意的字符，除外，有特殊的意义。描述了中各个的默认配置值。一个可以覆盖中的参数，一个可以包含几个一个只会受到它上面的的影响。和可以用作注释
两个进程，分别从一个从文件中，随机读的
;–start&job&file–
rw=randread
;–end&job&file–
job1和是空的，因为所有的描述参数是共享的。没有给出选项，会为每一个创建一个文件名，如果用命令写，则是：
$fio&–name=global&–rw=randread&–size=128m&–name=job1&–name=job2
多个进程随机写文件的实例
;–start&job&file&—
[random-writers]
ioengine=libaio
rw=randwrite
;–end&job&file–
没有只有一个
上一个实例的说明：采用每一个文件的队列长度为，采用随机写，采用的块，采用非，共有个进程，每个进程随机写的文件。也可以采用下面的命令
$fio&–name=random-writers&–ioengine=libaio&–iodepth=4&–rw=randwrite&–bs=32k&–direct=0&–size=64m&–numjobs=4
在中支持环境变量扩展。类似于可以作为选项的值（在号右边）。
$SIZE=64m&&NUMJOBS=4&fio&jobfile,fio
;–start&job&files–
[random-writers]
rw=randwrite
size=${SIZE}
numjobs=${NUMJOBS}
;–end&job&file–
将被扩展为
[random-writers]
rw=randwrite
;–end&job&file–
fio有一些保留，在内部将其替换成合适的值，这些是：
$pagesize&&&当前系统的页大小
$mb_memory&系统的总内存的大小，以为单位
$ncpus&在线有效的数
这引起在命令行中和中都可以用，当运行的时候，会自动的用当前系统的徝进行替换。支持简单的数学计算，如：
size=8*$mb_memory
str&字符串
time时间（
irange&整数范围
float_list&符点数列
一个包含的基本的参数
向文件发起的类型。
&1&readwrite=str,rw=str
read&顺序读
write&顺序写
randwrite&随机写
randread&随机读
rw,readwrite&顺序混合读写
randrw&随机混合读写
对于混合类型，混认是的读，的写，对于特定的类型，因为速度可能不同，结果可能会有稍有偏差
通过在在之后加可以配置在执行一下获取操作之前要执行的次数。如果后缀用于顺序类型的话，，那么将在每次之后，将这个值加到产生的之后。每次写之后将会跳过。它将顺序的转化为带有洞的顺序。参考选项。
&2&rw_sequencer=str
如果后有修饰的话，这个选项可以控制这个数字如何修饰产生的可以接收的值是：
sequential&产生顺序的
identical&产生相同的
‘sequential’仅用于随机。通常情况下，在每次之后，将会生成一个新的随机。，将会在每次之后执行，而不是每次之后。顺序已经是顺序的，再设置为将不会产生任何不同。会产生同相似的行为，只是它会连续产生次相同的，然后生成一个新的
产生的单元的大小，可以是一个孤立的值，也可以是一个范围。
&1&blocksize=int,bs=int
单次的默认为。如果是单个值的话，将会对读写都生效。如果是一个逗号，再跟一个值的话，则是仅对于写有效。也就是说，格式可以是或是。读使用的块，写使用的块。将使得写采用的块，读采用默认的值。
将会读写多少数据
&1&size=int
这个总共要传输的数据的大小。将会执行到所有的数据传输完成，除非设定了运行时间（选项）。除非有特定的选项和选项被设置，将会在定义的文件中平分这个大小。如果这个值不设置的话，将会使用这个文件或设备的总大小。如果这些文件不存在的话，选项一定要给出。也可以给出一个到的百分比。，将会使用给定的文件或设备的的空间。
发起的方式。
&1&ioengine=str
定义向文件发起的方式
sync&基本的用来作定位
psync&基本的
vsync&基本的
libaio&Linux专有的异步。仅支持非的队列行为。
posixaio&glibc&posix异步
solarisaio&solaris独有的异步
windowsaio&windows独有的异步
mmap&文件通过内存映射到用户空间，使用写入和读出数据
splice&使用和在用户空间和内核之间传输数据
syslet-rw&使用系统调用来构造普通的异步
sg&SCSI&generic&sg&v3&io.可以是使用来同步，或是目标是一个字符设备，我们使用和执行异步
null&不传输任何数据，只是伪装成这样。主要用于训练使用，或是基本的目的。
net&根据给定的通过网络传输数据。根据具体的协议，这些选项将被用来说明建立哪种连接，协议选项将决定哪种协议被使用。
netsplice&像，但是使用来映射数据和发送接收数据。
cpuio&不传输任何的数据，但是要根据和选项占用周期将使用不做任何的实际，但要占用的周期。在机器上，使用来获取需要的，因为仅会载入单个，然后占用需要的比例。
guasi&GUASI&IO引擎是一般的用于异步的用户空间异步系统调用接口
rdma&RDMA&I/O引擎支持内存语义（）和通道主义）用于和协议
external&指明要调用一个外部的引擎（二进制文件）。将载入下的这个引擎
如果引擎是异步的，这个指定我们需要保持的队列深度
&1&iodepth=int
加于文件之上的保持的单元。默认对于每个文件来说是，可以设置一个更大的值来提供并发度。大于不会影响同步引擎（除非这个选项被设置）。这会在使用并且设置的时候发生，因为在中不是异步的。在外部通过类似于这些工具来观察队列深度来保证这个队列深度是我们想要的。这个可以参考褚霸的博客
&1&direct=bool
true,则标明采用同效果一样。和不支持，在同步引擎不支持
&2&buffered=bool
true,则标明采用。是的反义词，默认是
负载将分发到几个文件之中
&1&nrfiles=int
用于这个的文件数目默认为
&2&openfiles=int
在同一时间可以同时打开的文件数目，默认同相等，可以设置小一些，来限制同时打开的文件数目。
&1&numjobs=int
创建特定数目的副本。可能是创建大量的线程进程来执行同一件事。我们将这样一系列的，看作一个特定的
详细参数：
&1&name=str
job名，用于输出信息用的名字。如果不设置的话，输出信息时将采用，如果设置的话，将用设置的名字。在命令行中，这个参数有特殊的作用，标明一个新的开始。
&2&description=str
job的说明信息在运行的时候不起作用，只是在输出文件描述信息的时候才起作用。
&3&directory=str
使用的文件的路径前缀，默认是
&4&filename=str
一般情况下，会根据名，线程号，文件名来产生一个文件名。如果，想在多个之间共享同一个文件的话，可以设定一个名字来代替默认的名字如果是的话，文件名则是以这种格式如果是基于文件的话，可以通过分割来设定一系列的文件。希望打开和作为两个工作文件。
&5&opendir=str
让递归的添加目录下和子目录下的所有文件。
&6&lockfile=str
fio在文件上执行之前默认是不锁文件的，这样的话，当有多个线程在此文件上执行的话，会造成结果的不一致。这个选项可以用来共享文件的负载，支持的锁类型：
none&默认不使用锁
exclusive&排它锁
readwrite&读写锁
在后面可以加一个数字后缀，如果设置的话，每一个线程将会执行这个数字指定的后才会放弃锁，因为锁的开销是比较大的，所以这种方式可以加速。
&7&kb_base=int
size换算单位，默认为
&8&randrepeat=bool
对于随机负载，配置生成器的种子，使得路径是可以预估的，使得每次重复执行生成的序列是一样的。
&9&use_os_rand=bool
fio可以使用操作系统的随机数产生器，也可以使用内部的随机数产生器（基于），默认是采用内部的产生器质量更数，速度更快。
&7&fallocate=str
如何准备测试文件
none&不执行预分配空间
posix&通过预分配空间
keep&通过（设置）预分配空间
0&none的别名出于兼容性
1&posix的别名，出于兼容性
并不是在所有的平台上都有效，仅在上有效，不支持。默认为
&8&fadvise_hint=bool
默认将使用来告知内核要产生的类型，如果不想告诉来执行一些特定的类型的话，可行关闭这个选项。如果设置的话，将使用来作顺序，使用来做随机
&9&filesize=int
单个文件的大小，可以是一个范围，在这种情况下，将会在一个范围内选择一个大小来决定单个文件大小，如果没有设置的话，所有的文件将会是同样的大小。
&10&fill_device=bool,fill_fs=bool
填满空间直到达到终止条件，只对顺序写有意义。对于读负载，首行要填满挂载点，然后再启动，对于裸设备结点，这个设置则没有什么意义，因为，它的大小已被被文件系统知道了，此外写的超出文件将不会返回
&11&blockalign=int,ba=int
配置随机的对齐边界。默认是与的配置一致，对于，最小为因为它与依赖的硬件块大小，对于使用文件的随机来说，这个选项不起作用。
&14&blocksize_range=irange,bsrange=irange
不再采用单一的块大小，而是定义一个范围，将采用混合块大小单元大小一般是给定最小值的备数。同时应用于读写，当然也可以通过来隔开分别配置读写。
&15&bssplit=str
可以更为精确的控制产生的这个选项可以用来定义各个块大小所占的权重格式是
bssplit=blocksize/blocksize/percentage
bssplit=4k/10:64k/50;32k/40
产生的这样的负载：的块，的块的块
可以分别为读和写来设置
e.g.&bssplit=2k/50:4k/50,4k/90:8k/10
产生这样的负载：读（的块，的块），写（的块的块）
&16&blocksize_unaligned,bs_unaligned
如果这个选项被设置的，在范围内的大小都可以产生，这个选项对于没有作用，因为对于至少需要扇区对齐
&17&zero_buffers
如果这个选项设置的话，全部位将被初始为如果没有置位的话，将会是随机数
&18&refill_buffers
如果这个选项设置的话，将在每次之后都会将重新填满默认都会在初始是填满，以后重复利用。这个选项只有在没有设置的话，这个选项才有作用。
&19&scramble_buffer=bool
如果成本太高的话，但是负载要求不使用重复数据块，设置这个选项的话，可以轻微的改动内容，这种方法骗不过聪明的块压缩算法，但是可以骗过一些简单的算法。
&20&buffer_compress_percentage=int
如果这个设置的话，将会尝试提供可以压缩到特定级别的内容。是能完提供混合的和随机数来实现的。
&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切换时，如何选择文件，支持下面的选项
random&随机选择一个文件&
roundrobin&循环使用打开的文件，默认
sequential&完成一个文件后，再移动到下一个文件
这个选项可以加后缀数字，标明切换到下一个新的频繁程度。
e.g.&random:4&每次后，将会切换到一下随机的文件
&23&iodepth_batch_submit=int,iodepth_batch=int
这个定义了一次性提交几个，默认是，意味着一旦准备好就提交，这个选项可以用来一次性批量提交
&24&iodepth_batch_complete=int
这个选项定义了一次取回多少个，如果定义为的话，意味着我们将向内核请求最小为个
&25&iodepth_low=int
这个水位标志标明什么时候开始重新填充这个队列，默认是同是一样的，意味着，每时每刻都在尝试填满这个队列。如果设置为，而设置为的话，那么将等到下降到才开始重新填充
&26&offset=int
在文件特定的偏移开始读数据在这个之前的数据将不会被使用，有效的文件大小
&27&offset_increment=int
如果这个选项被设置的话，实际的线程号是从开始的一个计数器，对于每一个来说是递增的。这个选项对于几个同时并行在不交界的地方操作一个文件是有用的。
&28&fsync=int
如果写一个文件的话，每次传输完后，都会进行一次同步脏数据的操作。
e.g.&fsync=int
fio每次写之后，同步一次文件。如果采用，不需要使用同步文件
对于引擎的话，可以在任何情况下同步磁盘
&29&fdatasync=int
同，但是采用来同步数据，但不同步元数据
&30&sync_file_range=str:val
对于每个写操作，将执行。将跟踪从上次调用之扣的写范围，可以是以下的选择
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将在每次写后使用
&31&overwrite=bool
如果是的话，写一个文件的话，将会覆盖已经存在的数据。如果文件不存在的话，它将会在写阶段开始的时候创建这个文件。
&32&end_fsync=bool
如果是的话，当退出的话，将会同步文件内容
&33&fsync_on_close=bool
如果是的话，关闭时，将会同步脏文件，不同于的时，它将会在每个文件关闭时都会发生，而不是只在结束时。
&34&rwmixread=int
混合读写中，读占的百分比
&35&rwmixwrite=int
混合读写中，写占的百分比；如果和同时使用的话并且相加不等于的话，第二个值将会覆盖第一个值。这可能要干扰比例的设定如果要求来限制读和写到一定的比率。在果在这种情况下，那么分布会的有点的不同。
&36&norandommap
一般情况下，在做随机时，将会覆盖文件的每一个如果这个选项设置的话，将只是获取一个新的随机而不会查询过去的历史。这意味着一些块可能没有读或写，一些块可能要读写很多次。在个选项与互斥，并只有多个块大小（）正在使用，因为只会记录完整的块的重写。
&37&softrandommap=bool
See&norandommap.&If&fio&runs&with&the&random&block&map&enabled&and&it&fails&to&allocate&the&map,&if&this&option&is&set&it&will&continue&without&a&random&block&map.&As&coverage&will&not&be&as&complete&as&with&random&maps,&this&option&is&disabled&by&default.
&38&nice=int
根据给定的值来运行这个
&39&prio=int
设置的优先级，将这个值限制在之间，是最高的。
&40&prioclass=int
设置优先级等级。
&41&thinktime=int
上一个完成之后，拖延毫秒，然后跳到下一个。可以用来访真应用进行的处理。
&42&thinktime_spin=int
只有在设置时才有效，在为了完规定的时间之前，假装花费时间来做一些与数据接收有关的事情。
&43&thinktime_blocks
只有在设置时才有效，控制在等等的时间内产生多少个，如果没有设置的话，这个值将是，每次后，都会将等待。
&44&rate=int
限制的带宽。
e.g.rate=500k,限制读和写到
e.g.rate=1m,500k,限制读到，限制写到
e.g.rate=,500k&,&限制写到
e.g.rate=500k,&限制读到
&45&ratemin=int
告诉尽最在能力来保证这个最小的带宽，如果不能满足这个需要，将会导致程序退出。
&46&rate_iops=int
将带宽限制到固定数目的，基本上同一样，只是独立于带宽，如果是指定了一个范围，而不是一个固定的值的话，最小将会作为标准。
&47&rate_iops_min=int
如果达不到这个的话，将会导致退出。
&48&ratecycle=int
几个毫秒内的平均带宽。用于和
&49&cpumask=int
设置使用的给出的参数是一个掩码来设置可以运行的。所以，如果要允许在和上的话，可以通过进制数来设置（），或是。查看的。它可能并不是支持所有的操作系统和版本。
&50&cpus_allowed=str
功能同一样，但是允许通过一段文本来设置允许的。上面的例子可是这样写。这个选项允许设置一个范围，如
&51&startdelay=time
fio启动几秒后再启动。只有在文件包含几个时才有效，是为了将某个延时几秒后执行。
&52&runtime=time
控制在执行设定的时间后退出执行。很难来控制单个的运行时间，所以这个参数是用来控制总的运行时间。
&53&time_based
如果设置的话，即使已被完全读写或写完，也要执行完规定的时间。它是通过循环执行相同的负载来实现的。
&54&ramp_tim=time
设定在记录任何性能信息之前要运行特定负载的时间。这个用来等性能稳定后，再记录日志结果，因此可以减少生成稳定的结果需要的运行时间。
&55&invalidate=bool
Invalidate&the&buffer/page&cache&parts&for&this&file&prior&to&starting&io.&Defaults&to&true.
&56&sync=bool
使用来进行写。对于多数引擎，这意味着使用
&57&iomem=str,mem=str
fio可以使用各种各样的类型的内存用来单元
malloc&使用
shm&使用共享内存通过分配
shmhuge&同一样，可以使用
mmap&使用。可以是匿名内存，或是支持的文件，如果一个文件名在选项后面设置的话，格式是
mmaphuge&使用在扣面添加文件名，
分配的区域是由允许的最大队列的长度。对于和，系统应该有空闲的页来分配。这个可以通过检测和设置来实现（）。假设一个是。所以要计算对于一个文件需要的数量，加上所有的队列长度再乘以最大块大小，然后除以每个的大小。可以通过查看来看的大小。如果通过设置来使得不允许分配，使用或是将会失败。
mmaphuge需要挂载而且要指定文件的位置，所以如果要挂载在下的话，可以使用
&58&iomem_align=int
标明内存缓冲的内存对齐方式。
&59&hugepage-size=int
设置的大小。至少要与系统的设定相等。默认是，必然是的倍数，所以用是用来避免出现不是的整数次方的情况。
&60&exitall
当一个退出时，会终止运行其它的，默认是等待所有的都完成，才退出，但有时候这并不是我们想要的。
&61&bwavgtime=int
在给定时间内的平均带宽。值是以毫秒为单位的
&62&iopsavgtime=int
在给定时间内的平均，值是以毫秒为单位的
&63&create_serialize=bool
job将会串行化创建这将会用来避免数据文件的交叉，这依赖于文件系统和系统的数
&64&create_fsync=bool
创建后同步数据文件，这是默认的值
&65&create_on_open=bool
不会为预先创建文件，只是在要向文件发起的时候，才创建
&66&create_only=bool
如果设置为的话，将只运行到的配置阶段。如果文件需要部署或是更新的磁盘的话，只有上面的事才会做，实际的文件内容并没有执行。
&67&pre_read=bool
如果这个选项被设置的话，在执行操作之前，文件将会被预读到内存这会删除标志，因为预读数据，然后丢弃中的数据的话，是没有意义的。这只是对可以的引擎有效，因为这允许读相同的数据多次。因此对于和不起作用。
&68&unlink=bool
完成后将删除产生的文件。默认是如果设置为的话，将会花很多时间重复创建这些文件。
&69&loops=int
重复运行某个多次，默认是
&70&do_verify=bool
写完成后，执行一个校验的阶段，只有当设置的时候才有效。默认是
&80&verify=str
写一个文件时，每次执行完一个扣，可以检验文件内容允许的校验算法是：
md5,crc64,crc32c,crc32c-intel,crc32,crc16,crc7,sha512,sha256,sha1,meta,null.
这个选项可以用来执行重复的测试，来保证写数据已经正确的读回。如果是或随机读，将假设它将会检验先前写的文件。如果是各种格式的写，将会是对新写入的数据进行校验。
&81&verifysort=bool
如果设置的话，
&82&verify_offset=int
Swap&the&verification&header&with&data&somewhere&else&in&the&block&before&writing.&Its&swapped&back&before&verifying.
&83&verify_interval=int
Write&the&verification&header&at&a&finer&granularity&than&the&blocksize.&It&will&be&written&for&chunks&the&size&of&header_interval.&blocksize&should&divide&this&evenly
&84&verify_pattern=str
&85&verify_fatal=bool
&86&verify_dump=bool
&87&verify_async=int
&88&verify_async_cpus=str
&89&verify_backlog=int
&90&verify_backlog_batch=int
&91&stonewall,wait_for_previous
等待先前的执行完成后，再启动一个新的。可以用来在文件中加入串行化的点。也用来启动一个新
&92&new_group
启动一个新的。如果这个选项没有设置的话，在文件中的将属于相同的，除非通过隔开
&93&group_reporting
如果设置的话，我们感兴趣的可能是打印的统计值，而不是一个单独的。这在的值很大时，一般是设置为的，可以减少输出的信息量。如果设置的话，将会显示最终的而不是每一个都会显示
&94&thread
fio默认会使用创建，如果这个选项设置的话，将使用来创建线程
&95&zonesize=int
将一个文件分为设定的大小的
&96&zoneskip=int
跳过这个的数据都被读完后，会跳过设定数目的
&97&write_iolog=str
将模式写到一个指定的文件中。为每一个指定一个单独的文件，否则将会分散的的，文件将会冲突。
&98&read_iolog=str
将开一个指定的文件，回复里面的日志。这可以用来存储一个负载，并进行重放。给出的也可以是一个二进制文件，允许来重放通过获取的负载。
&99&replay_no_stall
当使用重放时，默认是尝试遵守这个时间戳，在每个之前会有适当的延迟。通过设置这个属性，将不会遵守这个时间戳，会根据期望的顺序，尝试回复，越快越好。结果就是相同类型的，但是不同的时间
&101&replay_redirect
当使用回放时，默认的行为是在每一个来源的设备上回放。这在有些情况是不是期望的，比如在另一台机器上回放，或是更换了硬件，使是映射关系发生了改变。将会导致所有的回放到单个设备上，不管这些来源于哪里。将会使得所有的都会重定向到这就意味着多个设备的数据都会重放到一个设置，如果想来自己多个设备的数据重放到多个设置的话，需要处理我们的，生成独立的，再使用进行重放，不过这会破坏多个设备访问的严格次序。
&102&write_bw_log=str
在写这个的带宽日志。可以在他们的生命周期内存储的带宽数据。内部的脚本可以使用将这些文本转化成图。
&103&write_lat_log=str
同类似，只是这个选项可以存储提交，完成和总的响应时间。如果没有指定文件名，默认的文件名是。即使给出了文件名，也会添加两种类型的。
e.g.如果我们指定
实际的名将是和这会帮助来自动处理
&104&write_iops_log=str
类似于但是写的是如果没有给定文件名的话，默认的文件名是。
&105&log_avg_msec=int
默认，每完成一个将会记录一个日志（）。当向磁盘写日志的时候，将会很快变的很大。设置这个选项的话，将会在一定的时期内平均这些值，指少日志的数量，默认是
&106&lockmem=int
使用可以指定特定的内存大小，用来访真少量内存
&107&exec_preren=str
运行之前，通过过执行指定的命令
&108&exec_postrun=str
job执行完成后，通过执行指定的命令
&109&ioscheduler=str
在运行之前，尝试将文件所在的设备切换到指定的调度器。
&110&cpuload=int
如果是非常占用周期的，可以指定战胜周期的百分比。
&120&cpuchunks=int
如果是非常战胜周期的，将分拆为时间的，以毫秒为单位
&121&disk_util=bool
产生磁盘利用率统计信息。默认是打开的
&122&disable_lat=bool
延迟的有效数字。
&123&disable_clat=bool
&124&disable_slat_bool
&125&disable_bw=bool
&126&clat_percentiles=bool
允许报告完成完成响应时间的百分比
&127&percentile_list=float_list
&128&gtod_reduce=bool
&129&gtod_cpu=int
&130&continue_on_error=str
一般情况下，一旦检测到错误，将会退出这个如果这个选项设置的话，将会一直执行到有错误（或）或是执行时间耗完，或是指定的完成。如果这个选项设置的话，将会添加两个状态，总的错误计数和第一个。允许的值是
none&全部或检验错误后，都会退出
read&读错误时会继续执行，其它的错误会退出
write&写错误时会继续执行，其它的错误会退出
io&任何时会继续执行，其它的错误会退出
verify&校验错误时会继续执行，其它的错误会退出
all&遇到所有的错误都会继续执行
&131&cgroup=str
&132&cgroup_weitht=int
&133&cgroup_weight=int
&134&cgroup_nodelete=bool
&135&uid=int
不是使用调用者的用户来执行，而是指定用户
&136&gid=int
&137&flow_id=int
&138&flow=int
&139&flow_watermark=int
&140&flow_sleep=int
下面的参数只对指定的引擎有效：
[libaio]&userspace_reap
[netsplice]hostname=str
[net]hostname=str
[netsplice]port=int
[netsplice]proto=str
[net]protocol=str
[net]proto=str
[net]listen
在运行时，将打印当前创建的状态
Threads:&1:&[_r]&[24.8%&done]&[&13509/&&8334&kb/s]&[eta&00h:01m:31s]
P &&线程已经启动，还没有启动
C 线程启动
I 纯种已经初始化，等待中
p 线程运行中，预读文件
M 混合顺序读写
m 混合随机读写
F 等待执行
V 运行，检验写的数据
E 线程退出还没有被主线程获取状态
_ Thread&reaped,&or
X Thread&reaped,&exited&with&an&error.
K Thread&reaped,&exited&due&to&signal.
其它的值都是可以自解释的：
当前正在运行的线程数。
从上次检查之后的速度（读速度写速度）
估计的完成百分比
整个的估计完成时间
当完成的时候（或是通过终止的时候），将会打印每一个线程的数据，每个的数据，和磁盘数据。
io= 执行了多少的
bw= 平均带宽
iops=&&&IOPS
runt= 线程运行时间
slat&提交延迟
clat&完成延迟
lat响应时间
IO&depths=io队列
IO&submit=单个提交要提交的数
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= 总共执行了多少的
aggrb= group总带宽
minb= 最小.平均带宽
maxb= 最大平均带宽
mint= group中线程的最短运行时间
maxt= group中线程的最长运行时间
ios= 所有总共执行的数
merge= 总共发生的合并数
ticks= Number&of&ticks&we&kept&the&disk&busy.
io_queue= 花费在队列上的总共时间
util= 磁盘利用率
为了便于脚本分析，可能需要将结果生成表或图，可以生成以分号分割的结果。
trace文件格式