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,
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.
+
libaio Linux native asynchronous io.
posixaio glibc posix asynchronous io.
or receive, if the latter only the port
argument is used.
- cpu Doesn't transfer any data, but burns CPU
+ netsplice Like net, but uses splice/vmsplice to
+ map data and send/receive.
+
+ 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
of milliseconds.
cpumask=int Set the CPU affinity of this job. The parameter given is a
- bitmask of allowed CPU's the job may run on. See man
+ bitmask of allowed CPU's the job may run on. So if you want
+ the allowed CPUs to be 1 and 5, you would pass the decimal
+ value of (1 << 1 | 1 << 5), or 34. See man
sched_setaffinity(2). This may not work on all supported
operating systems or kernel versions.
+cpus_allowed=str Controls the same options as cpumask, but it allows a text
+ setting of the permitted CPUs instead. So to use CPUs 1 and
+ 5, you would specify cpus_allowed=1,5.
+
startdelay=int Start this job the specified number of seconds after fio
has started. Only useful if the job file contains several
jobs, and you want to delay starting some jobs to a certain
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.
+
+ pattern Fill the IO buffers with a specific pattern,
+ that we can use to verify. Depending on the
+ width of the pattern, fio will fill 1/2/3/4
+ bytes of the buffer at the time. The pattern
+ cannot be larger than a 32-bit quantity. The
+ given pattern is given as a postfix to this
+ option, ala: verify=pattern:0x5a. It accepts
+ both hex and dec values.
+
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_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
_ Thread reaped.
The other values are fairly self explanatory - number of threads
-currently running and doing io, rate of io since last check, and the estimated
-completion percentage and time for the running group. It's impossible to
-estimate runtime of the following groups (if any).
+currently running and doing io, rate of io since last check (read speed
+listed first, then write speed), and the estimated completion percentage
+and time for the running group. It's impossible to estimate runtime of
+the following groups (if any).
When fio is done (or interrupted by ctrl-c), it will show the data for
each thread, group of threads, and disks in that order. For each data
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%,
slat= Submission latency (avg being the average, stdev being the
standard deviation). This is the time it took to submit
the io. For sync io, the slat is really the completion
- latency, since queue/complete is one operation there.
+ latency, since queue/complete is one operation there. This
+ value can be in miliseconds or microseconds, fio will choose
+ the most appropriate base and print that. In the example
+ above, miliseconds is the best scale.
clat= Completion latency. Same names as slat, this denotes the
time from submission to completion of the io pieces. For
sync io, clat will usually be equal (or very close) to 0,
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
projects / fio.git / blobdiff