linux使用FIO測試磁盤的iops

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

<31>overwrite=bool

若是是true的話，寫一個文件的話，將會覆蓋已經存在的數據。若是文件不存在的話，它將會在寫階段開始的時候建立這個文件。

<32>end_fsync=bool

若是是true的話，當job退出的話，fsync將會同步文件內容

<33>fsync_on_close=bool

若是是true的話，關閉時，fio將會同步髒文件，不一樣於end_fsync的時，它將會在每一個文件關閉時都會發生，而不是隻在job結束時。

<34>rwmixread=int

混合讀寫中，讀佔的百分比

<35>rwmixwrite=int

混合讀寫中，寫佔的百分比；若是rwmixread=int和rwmixwrite=int同時使用的話而且相加不等於100%的話，第二個值將會覆蓋第一個值。這可能要干擾比例的設定,若是要求fio來限制讀和寫到必定的比率。在果在這種狀況下，那麼分佈會的有點的不一樣。

<36>norandommap

通常狀況下，fio在作隨機IO時，將會覆蓋文件的每個block.若是這個選項設置的話，fio將只是獲取一個新的隨機offset,而不會查詢過去的歷史。這意味着一些塊可能沒有讀或寫，一些塊可能要讀/寫不少次。在個選項與verify=互斥，並只有多個塊大小（bsrange=）正在使用，由於fio只會記錄完整的塊的重寫。

<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

根據給定的nice值來運行這個job

<39>prio=int

設置job的優先級，linux將這個值限制在0-7之間，0是最高的。

<40>prioclass=int

設置優先級等級。

<41>thinktime=int

上一個IO完成以後，拖延x毫秒，而後跳到下一個。能夠用來訪真應用進行的處理。

<42>thinktime_spin=int

只有在thinktime設置時纔有效，在爲了sleep完thinktime規定的時間以前，僞裝花費CPU時間來作一些與數據接收有關的事情。

<43>thinktime_blocks

只有在thinktime設置時纔有效，控制在等等‘thinktime’的時間內產生多少個block，若是沒有設置的話，這個值將是1，每次block後，都會將等待‘thinktime’us。

<44>rate=int

限制job的帶寬。

e.g.rate=500k,限制讀和寫到500k/s

e.g.rate=1m,500k,限制讀到1MB/s，限制寫到500KB/s

e.g.rate=,500k , 限制寫到500kb/s

e.g.rate=500k, 限制讀到500KB/s

<45>ratemin=int

告訴fio盡最在能力來保證這個最小的帶寬，若是不能知足這個須要，將會致使程序退出。

<46>rate_iops=int

將帶寬限制到固定數目的IOPS，基本上同rate同樣，只是獨立於帶寬，若是job是指定了一個block size範圍，而不是一個固定的值的話，最小blocksize將會做爲標準。

<47>rate_iops_min=int

若是fio達不到這個IOPS的話，將會致使job退出。

<48>ratecycle=int

幾個毫秒內的平均帶寬。用於‘rate’和‘ratemin’

<49>cpumask=int

設置job使用的CPU.給出的參數是一個掩碼來設置job能夠運行的CPU。因此，若是要容許CPU在1和5上的話，能夠經過10進制數來設置（1<<1 | 1<<5），或是34。查看sched_setaffinity的man page。它可能並非支持全部的操做系統和kernel版本。This option doesn’t work well for a higher CPU count than what you can store in an integer mask, so it can only control cpus 1-32. For boxes with larger CPU counts, use cpus_allowed.

<50>cpus_allowed=str

功能同cpumask同樣，可是容許經過一段文原本設置容許的CPU。e.g.上面的例子但是這樣寫cpus_allowed=1,5。這個選項容許設置一個CPU範圍，如cpus_allowed=1,5,8-15

<51>startdelay=time

fio啓動幾秒後再啓動job。只有在job文件包含幾個jobs時纔有效，是爲了將某個job延時幾秒後執行。

<52>runtime=time

控制fio在執行設定的時間後退出執行。很難來控制單個job的運行時間，因此這個參數是用來控制總的運行時間。

<53>time_based

若是設置的話，即便file已被徹底讀寫或寫完，也要執行完runtime規定的時間。它是經過循環執行相同的負載來實現的。

<54>ramp_tim=time

設定在記錄任何性能信息以前要運行特定負載的時間。這個用來等性能穩定後，再記錄日誌結果，所以能夠減小生成穩定的結果須要的運行時間。Note that the ramp_time is considered lead in time for a job, thus it will increase the total runtime if a special timeout or runtime is specified.

<55>invalidate=bool

Invalidate the buffer/page cache parts for this file prior to starting io. Defaults to true.

<56>sync=bool

使用sync來進行buffered寫。對於多數引擎，這意味着使用O_SYNC

<57>iomem=str,mem=str

fio可使用各類各樣的類型的內存用來io單元buffer.

malloc 使用malloc()

shm 使用共享內存.經過shmget()分配

shmhuge 同shm同樣，可使用huge pages

mmap 使用mmap。能夠是匿名內存，或是支持的文件，若是一個文件名在選項後面設置的話，格式是mem=mmap:/path/to/file

mmaphuge 使用mmapped huge file.在mmaphuge扣面添加文件名，alamem=mmaphuge:/hugetlbfs/file

分配的區域是由job容許的最大block size * io 隊列的長度。對於shmhuge和mmaphuge，系統應該有空閒的頁來分配。這個能夠經過檢測和設置reading/writing /proc/sys/vm/nr_hugepages來實現（linux）。FIO假設一個huge page是4MB。因此要計算對於一個JOB文件須要的Huge page數量，加上全部jobs的隊列長度再乘以最大塊大小，而後除以每一個huge page的大小。能夠經過查看/proc/meminfo來看huge pages的大小。若是經過設置nr_hugepages=0來使得不容許分配huge pages，使用mmaphug或是shmhuge將會失敗。

mmaphuge須要掛載hugelbfs並且要指定文件的位置，因此若是要掛載在/huge下的話，可使用mem=mmaphuge:/huge/somefile

<58>iomem_align=int

標明IO內存緩衝的內存對齊方式。Note that the given alignment is applied to the first IO unit buffer, if using iodepth the alignment of the following buffers are given by the bs used. In other words, if using a bs that is a multiple of the page sized in the system, all buffers will be aligned to this value. If using a bs that is not page aligned, the alignment of subsequent IO memory buffers is the sum of the iomem_align and bs used.

<59>hugepage-size=int

設置huge page的大小。至少要與系統的設定相等。默認是4MB，必然是MB的倍數，因此用hugepage-size=Xm是用來避免出現不是2的整數次方的狀況。

<60>exitall

當一個job退出時，會終止運行其它的job，默認是等待全部的job都完成，FIO才退出，但有時候這並非咱們想要的。

<61>bwavgtime=int

在給定時間內的平均帶寬。值是以毫秒爲單位的

<62>iopsavgtime=int

在給定時間內的平均IOPS，值是以毫秒爲單位的

<63>create_serialize=bool

job將會串行化建立job,這將會用來避免數據文件的交叉，這依賴於文件系統和系統的CPU數

<64>create_fsync=bool

建立後同步數據文件，這是默認的值

<65>create_on_open=bool

不會爲IO預先建立文件，只是在要向文件發起IO的時候，才建立open()

<66>create_only=bool

若是設置爲true的話，fio將只運行到job的配置階段。若是文件須要部署或是更新的磁盤的話，只有上面的事纔會作，實際的文件內容並無執行。

<67>pre_read=bool

若是這個選項被設置的話，在執行IO操做以前，文件將會被預讀到內存.這會刪除‘invalidate’標誌，由於預讀數據，而後丟棄cache中的數據的話，是沒有意義的。這只是對能夠seek的IO引擎有效，由於這容許讀相同的數據屢次。所以對於network和splice不起做用。

<68>unlink=bool

完成後將刪除job產生的文件。默認是not,若是設置爲true的話，將會花不少時間重複建立這些文件。

<69>loops=int

重複運行某個job屢次，默認是1

<70>do_verify=bool

寫完成後，執行一個校驗的階段，只有當verify設置的時候纔有效。默認是true

<80>verify=str

寫一個文件時，每次執行完一個job扣，fio能夠檢驗文件內容.容許的校驗算法是：

md5,crc64,crc32c,crc32c-intel,crc32,crc16,crc7,sha512,sha256,sha1,meta,null.

這個選項能夠用來執行重複的burn-in測試，來保證寫數據已經正確的讀回。若是是read或隨機讀，fio將假設它將會檢驗先前寫的文件。若是是各類格式的寫，verify將會是對新寫入的數據進行校驗。

<81>verifysort=bool

若是設置的話，fio will sort written verify blocks when it deems it faster to read them back in a sorted manner. This is often the case when overwriting an existing file, since the blocks are already laid out in the file system. You can ignore this option unless doing huge amounts of really fast IO where the red-black tree sorting CPU time becomes significant.

<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

等待先前的job執行完成後，再啓動一個新的job。能夠用來在job文件中加入串行化的點。stone wall也用來啓動一個新reporting group

<92>new_group

啓動一個新的reporting group。若是這個選項沒有設置的話，在job文件中的job將屬於相同的reporting group，除非經過stonewall隔開

<93>group_reporting

若是‘numjobs’設置的話，咱們感興趣的多是打印group的統計值，而不是一個單獨的job。這在‘numjobs’的值很大時，通常是設置爲true的，能夠減小輸出的信息量。若是‘group_reporting’設置的話，fio將會顯示最終的per-groupreport而不是每個job都會顯示

<94>thread

fio默認會使用fork()建立job，若是這個選項設置的話，fio將使用pthread_create來建立線程

<95>zonesize=int

將一個文件分爲設定的大小的zone

<96>zoneskip=int

跳過這個zone的數據都被讀完後，會跳過設定數目的zone.

<97>write_iolog=str

將IO模式寫到一個指定的文件中。爲每個job指定一個單獨的文件，不然iolog將會分散的的，文件將會衝突。

<98>read_iolog=str

將開一個指定的文件，回覆裏面的日誌。這能夠用來存儲一個負載，並進行重放。給出的iolog也能夠是一個二進制文件，容許fio來重放經過blktrace獲取的負載。

<99>replay_no_stall

當使用read_iolog重放I/O時，默認是嘗試遵照這個時間戳，在每一個IOPS以前會有適當的延遲。經過設置這個屬性，將不會遵照這個時間戳，會根據指望的順序，嘗試回覆，越快越好。結果就是相同類型的IO，可是不一樣的時間

<101>replay_redirect

當使用read_iolog回放IO時，默認的行爲是在每個IOP來源的major/minor設備上回放IOPS。這在有些狀況是否是指望的，好比在另外一臺機器上回放，或是更換了硬件，使是major/minor映射關係發生了改變。Replay_redirect將會致使全部的IOPS回放到單個設備上，無論這些IO來源於哪裏。e.g.replay_redirect=/dev/sdc將會使得全部的IO都會重定向到/dev/sdc.這就意味着多個設備的數據都會重放到一個設置，若是想來本身多個設備的數據重放到多個設置的話，須要處理咱們的trace，生成獨立的trace，再使用fio進行重放，不過這會破壞多個設備訪問的嚴格次序。

<102>write_bw_log=str

在job file寫這個job的帶寬日誌。能夠在他們的生命週期內存儲job的帶寬數據。內部的fio_generate_plots腳本可使用gnuplot將這些文本轉化成圖。

<103>write_lat_log=str

同write_bw_log相似，只是這個選項能夠存儲io提交，完成和總的響應時間。若是沒有指定文件名，默認的文件名是jobname_type.log。即便給出了文件名，fio也會添加兩種類型的log。

e.g.若是咱們指定write_lat_log=foo

實際的log名將是foo_slat.log,foo_slat.log和foo_lat.log.這會幫助fio_generate_plot來自動處理log

<104>write_iops_log=str

相似於write_bw_log,可是寫的是IOPS.若是沒有給定文件名的話，默認的文件名是jobname_type.log。

<105>log_avg_msec=int

默認，fio每完成一個IO將會記錄一個日誌（iops,latency,bw log）。當向磁盤寫日誌的時候，將會很快變的很大。設置這個選項的話，fio將會在必定的時期內平均這些值，指少日誌的數量，默認是0

<106>lockmem=int

使用mlock能夠指定特定的內存大小，用來訪真少許內存

<107>exec_preren=str

運行job以前，經過過system執行指定的命令

<108>exec_postrun=str

job執行完成後，經過system執行指定的命令

<109>ioscheduler=str

在運行以前，嘗試將文件所在的設備切換到指定的調度器。

<110>cpuload=int

若是job是很是佔用CPU週期的，能夠指定打敗CPU週期的百分比。

<120>cpuchunks=int

若是job是很是打敗CPU週期的，將load分拆爲時間的cycles，以毫秒爲單位

<121>disk_util=bool

產生磁盤利用率統計信息。默認是打開的

<122>disable_lat=bool

延遲的有效數字。Disable measurements of total latency numbers. Useful only for cutting back the number of calls to gettimeofday,as that does impact performance at really high IOPS rates.Note that to really get rid of a large amount of these calls, this option must be used with disable_slat and disable_bw as well.

<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

通常狀況下，一旦檢測到錯誤，fio將會退出這個job.若是這個選項設置的話，fio將會一直執行到有‘non-fatal錯誤‘（EIO或EILSEQ）或是執行時間耗完，或是指定的I/Osize完成。若是這個選項設置的話，將會添加兩個狀態，總的錯誤計數和第一個error。容許的值是

none 所有IO或檢驗錯誤後，都會退出

read 讀錯誤時會繼續執行，其它的錯誤會退出

write 寫錯誤時會繼續執行，其它的錯誤會退出

io 任何IO error時會繼續執行，其它的錯誤會退出

verify 校驗錯誤時會繼續執行，其它的錯誤會退出

all 遇到全部的錯誤都會繼續執行

<131>cgroup=str

<132>cgroup_weitht=int

<133>cgroup_weight=int

<134>cgroup_nodelete=bool

<135>uid=int

不是使用調用者的用戶來執行，而是指定用戶ID

<136>gid=int

設置group id

<137>flow_id=int

<138>flow=int

<139>flow_watermark=int

<140>flow_sleep=int

下面的參數只對指定的IO引擎有效：

[libaio] userspace_reap

[netsplice]hostname=str

[net]hostname=str

[netsplice]port=int

[netsplice]proto=str

[net]protocol=str

[net]proto=str

[net]listen

輸出

在運行時，fio將打印當前job建立的狀態

e.g.

Threads: 1: [_r] [24.8% done] [ 13509/  8334 kb/s] [eta 00h:01m:31s]

生命週期

P   線程已經啓動，尚未啓動

C 線程啓動

I 純種已經初始化，等待中

p 線程運行中，預讀文件

R 順序讀

r 隨機讀

W 順序寫

w 隨機寫

M 混合順序讀寫

m 混合隨機讀寫

F 等待執行fsync()

V 運行，檢驗寫的數據

E 線程退出,尚未被主線程獲取狀態

_ Thread reaped, or

X Thread reaped, exited with an error.

K Thread reaped, exited due to signal.

 

其它的值都是能夠自解釋的：

當前正在運行的IO線程數。

從上次檢查以後的IO速度（讀速度/寫速度）

估計的完成百分比

整個group的估計完成時間

 

當fio完成的時候（或是經過ctrl-c終止的時候），將會打印每個線程的數據，每一個group的數據，和磁盤數據。

 

io= 執行了多少M的IO

bw= 平均IO帶寬

iops=   IOPS

runt= 線程運行時間

slat 提交延遲

clat 完成延遲

lat響應時間

bw 帶寬

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= 磁盤利用率

 

爲了便於腳本分析，可能須要將結果生成表或圖，fio能夠生成以分號分割的結果。

trace文件格式