a string. The following types are used:
str String. This is a sequence of alpha characters.
-int Integer. A whole number value, can be negative.
+int Integer. A whole number value, can be negative. If prefixed with
+ 0x, the integer is assumed to be of base 16 (hexidecimal).
siint SI integer. A whole number value, which may contain a postfix
describing the base of the number. Accepted postfixes are k/m/g,
meaning kilo, mega, and giga. So if you want to specify 4096,
opendir=str Tell fio to recursively add any file it can find in this
directory and down the file system tree.
+lockfile=str Fio defaults to not doing any locking files before it does
+ IO to them. If a file or file descriptor is shared, fio
+ can serialize IO to that file to make the end result
+ consistent. This is usual for emulating real workloads that
+ share files. The lock modes are:
+
+ none No locking. The default.
+ exclusive Only one thread/process may do IO,
+ excluding all others.
+ readwrite Read-write locking on the file. Many
+ readers may access the file at the
+ same time, but writes get exclusive
+ access.
+
+ The option may be post-fixed with a lock batch number. If
+ set, then each thread/process may do that amount of IOs to
+ the file before giving up the lock. Since lock acqusition is
+ expensive, batching the lock/unlocks will speed up IO.
+
readwrite=str
rw=str Type of io pattern. Accepted values are:
and limited to 'size' in total (if that is given). If not
given, each created file is the same size.
+fill_device=bool Sets size to something really large and waits for ENOSPC (no
+ space left on device) as the terminating condition. Only makes
+ sense with sequential write.
+
blocksize=siint
bs=siint The block size used for the io units. Defaults to 4k. Values
can be given for both read and writes. If a single siint is
writes, however a second range can be given after a comma.
See bs=.
+bssplit=str Sometimes you want even finer grained control of the
+ block sizes issued, not just an even split between them.
+ This option allows you to weight various block sizes,
+ so that you are able to define a specific amount of
+ block sizes issued. The format for this option is:
+
+ bssplit=blocksize/percentage:blocksize/percentage
+
+ for as many block sizes as needed. So if you want to define
+ a workload that has 50% 64k blocks, 10% 4k blocks, and
+ 40% 32k blocks, you would write:
+
+ bssplit=4k/10:64k/50:32k/40
+
+ Ordering does not matter. If the percentage is left blank,
+ fio will fill in the remaining values evenly. So a bssplit
+ option like this one:
+
+ bssplit=4k/50:1k/:32k/
+
+ would have 50% 4k ios, and 25% 1k and 32k ios. The percentages
+ always add up to 100, if bssplit is given a range that adds
+ up to more, it will error out.
+
blocksize_unaligned
bs_unaligned If this option is given, any byte size value within bsrange
may be used as a block range. This typically wont work with
sync Basic read(2) or write(2) io. lseek(2) is
used to position the io location.
+ psync Basic pread(2) or pwrite(2) io.
+
+ vsync Basic readv(2) or writev(2) IO.
+
libaio Linux native asynchronous io.
posixaio glibc posix asynchronous io.
netsplice Like net, but uses splice/vmsplice to
map data and send/receive.
- cpu Doesn't transfer any data, but burns CPU
+ cpuio Doesn't transfer any data, but burns CPU
cycles according to the cpuload= and
cpucycle= options. Setting cpuload=85
will cause that job to do nothing but burn
- 85% of the CPU.
+ 85% of the CPU. In case of SMP machines,
+ use numjobs=<no_of_cpu> to get desired CPU
+ usage, as the cpuload only loads a single
+ CPU at the desired rate.
guasi The GUASI IO engine is the Generic Userspace
Asyncronous Syscall Interface approach
concurrency.
iodepth_batch=int This defines how many pieces of IO to submit at once.
- It defaults to the same as iodepth, but can be set lower
- if one so desires.
+ It defaults to 1 which means that we submit each IO
+ as soon as it is available, but can be raised to submit
+ bigger batches of IO at the time.
iodepth_low=int The low water mark indicating when to start filling
the queue again. Defaults to the same as iodepth, meaning
to repeat the same workload a given number of times. Defaults
to 1.
+do_verify=bool Run the verify phase after a write phase. Only makes sense if
+ verify is set. Defaults to 1.
+
verify=str If writing to a file, fio can verify the file contents
after each iteration of the job. The allowed values are:
md5 Use an md5 sum of the data area and store
it in the header of each block.
+ crc64 Use an experimental crc64 sum of the data
+ area and store it in the header of each
+ block.
+
crc32 Use a crc32 sum of the data area and store
it in the header of each block.
+ crc16 Use a crc16 sum of the data area and store
+ it in the header of each block.
+
+ crc7 Use a crc7 sum of the data area and store
+ it in the header of each block.
+
+ sha512 Use sha512 as the checksum function.
+
+ sha256 Use sha256 as the checksum function.
+
+ meta Write extra information about each io
+ (timestamp, block number etc.). The block
+ number is verified.
+
null Only pretend to verify. Useful for testing
internals with ioengine=null, not for much
else.
can ignore this option unless doing huge amounts of really
fast IO where the red-black tree sorting CPU time becomes
significant.
+
+verify_offset=siint Swap the verification header with data somewhere else
+ in the block before writing. Its swapped back before
+ verifying.
+
+verify_interval=siint 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.
+
+verify_pattern=int If set, fio will fill the io buffers with this
+ pattern. Fio defaults to filling with totally random
+ bytes, but sometimes it's interesting to fill with a known
+ pattern for io verification purposes. Depending on the
+ width of the pattern, fio will fill 1/2/3/4 bytes of the
+ buffer at the time. The verify_pattern cannot be larger than
+ a 32-bit quantity.
+
+verify_fatal=bool Normally fio will keep checking the entire contents
+ before quitting on a block verification failure. If this
+ option is set, fio will exit the job on the first observed
+ failure.
stonewall Wait for preceeding jobs in the job file to exit, before
starting this one. Can be used to insert serialization
slat (msec): min= 0, max= 136, avg= 0.03, stdev= 1.92
clat (msec): min= 0, max= 631, avg=48.50, stdev=86.82
bw (KiB/s) : min= 0, max= 1196, per=51.00%, avg=664.02, stdev=681.68
- cpu : usr=1.49%, sys=0.25%, ctx=7969
+ cpu : usr=1.49%, sys=0.25%, ctx=7969, majf=0, minf=17
IO depths : 1=0.1%, 2=0.3%, 4=0.5%, 8=99.0%, 16=0.0%, 32=0.0%, >32=0.0%
issued r/w: total=0/32768, short=0/0
lat (msec): 2=1.6%, 4=0.0%, 10=3.2%, 20=12.8%, 50=38.4%, 100=24.8%,
only really useful if the threads in this group are on the
same disk, since they are then competing for disk access.
cpu= CPU usage. User and system time, along with the number
- of context switches this thread went through.
+ of context switches this thread went through, usage of
+ system and user time, and finally the number of major
+ and minor page faults.
IO depths= The distribution of io depths over the job life time. The
numbers are divided into powers of 2, so for example the
16= entries includes depths up to that value but higher
Submission latency: min, max, mean, deviation
Completion latency: min, max, mean, deviation
Bw: min, max, aggregate percentage of total, mean, deviation
- CPU usage: user, system, context switches
+ CPU usage: user, system, context switches, major faults, minor faults
IO depths: <=1, 2, 4, 8, 16, 32, >=64
IO latencies: <=2, 4, 10, 20, 50, 100, 250, 500, 750, 1000, >=2000
Text description