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

更多詳情見請繼續閱讀下一頁的精彩內容： http://www.linuxidc.com/Linux/2017-04/143255p2.htm