'#', the entire line is discarded as a comment.
So let's look at a really simple job file that defines two processes, each
-randomly reading from a 128MB file.
+randomly reading from a 128MiB file.
; -- start job file --
[global]
Here we have no global section, as we only have one job defined anyway.
We want to use async io here, with a depth of 4 for each file. We also
-increased the buffer size used to 32KB and define numjobs to 4 to
+increased the buffer size used to 32KiB and define numjobs to 4 to
fork 4 identical jobs. The result is 4 processes each randomly writing
-to their own 64MB file. Instead of using the above job file, you could
+to their own 64MiB file. Instead of using the above job file, you could
have given the parameters on the command line. For this case, you would
specify:
specified, use eg 10m for 10 minutes. Accepts s/m/h for seconds,
minutes, and hours, and accepts 'ms' (or 'msec') for milliseconds,
and 'us' (or 'usec') for microseconds.
-int SI integer. A whole number value, which may contain a suffix
- describing the base of the number. Accepted suffixes are k/m/g/t/p,
- meaning kilo, mega, giga, tera, and peta. The suffix is not case
- sensitive, and you may also include trailing 'b' (eg 'kb' is the same
- as 'k'). So if you want to specify 4096, you could either write
- out '4096' or just give 4k. The suffixes signify base 2 values, so
- 1024 is 1k and 1024k is 1m and so on, unless the suffix is explicitly
- set to a base 10 value using 'kib', 'mib', 'gib', etc. If that is the
- case, then 1000 is used as the multiplier. This can be handy for
- disks, since manufacturers generally use base 10 values when listing
- the capacity of a drive. If the option accepts an upper and lower
- range, use a colon ':' or minus '-' to separate such values. May also
- include a prefix to indicate numbers base. If 0x is used, the number
- is assumed to be hexadecimal. See irange.
+
+int Integer. A whole number value, which may contain an integer prefix
+ and an integer suffix.
+ [integer prefix]number[integer suffix]
+
+ The optional integer prefix specifies the number's base. The default
+ is decimal. 0x specifies hexadecimal.
+
+ The optional integer suffix specifies the number's units, and includes
+ an optional unit prefix and an optional unit. For quantities of data,
+ the default unit is bytes. For quantities of time, the default unit
+ is seconds.
+
+ With kb_base=1000, fio follows international standards for unit prefixes.
+ To specify power-of-10 decimal values defined in the International
+ System of Units (SI):
+ Ki means kilo (K) or 1000
+ Mi means mega (M) or 1000**2
+ Gi means giga (G) or 1000**3
+ Ti means tera (T) or 1000**4
+ Pi means peta (P) or 1000**5
+
+ To specify power-of-2 binary values defined in IEC 80000-13:
+ k means kibi (Ki) or 1024
+ M means mebi (Mi) or 1024**2
+ G means gibi (Gi) or 1024**3
+ T means tebi (Ti) or 1024**4
+ P means pebi (Pi) or 1024**5
+
+ With kb_base=1024 (the default), the unit prefixes are opposite from
+ those specified in the SI and IEC 80000-13 standards to provide
+ compatibility with old scripts. For example, 4k means 4096.
+
+ For quantities of data, an optional unit of 'B' may be included
+ (e.g., 'kB' is the same as 'k').
+
+ The integer suffix is not case sensitive (e.g., m/mi mean mebi/mega,
+ not milli). 'b' and 'B' both mean byte, not bit.
+
+ Examples with kb_base=1000:
+ 4 KiB: 4096, 4096b, 4096B, 4ki, 4kib, 4kiB, 4Ki, 4KiB
+ 1 MiB: 1048576, 1mi, 1024ki
+ 1 MB: 1000000, 1m, 1000k
+ 1 TiB: 1073741824, 1ti, 1024mi, 1048576ki
+ 1 TB: 1000000000, 1t, 1000m, 1000000k
+
+ Examples with kb_base=1024 (default):
+ 4 KiB: 4096, 4096b, 4096B, 4k, 4kb, 4kB, 4K, 4KB
+ 1 MiB: 1048576, 1m, 1024k
+ 1 MB: 1000000, 1mi, 1000ki
+ 1 TiB: 1073741824, 1t, 1024m, 1048576k
+ 1 TB: 1000000000, 1ti, 1000mi, 1000000ki
+
+ To specify times (units are not case sensitive):
+ D means days
+ H means hours
+ M mean minutes
+ s or sec means seconds (default)
+ ms or msec means milliseconds
+ us or usec means microseconds
+
+ If the option accepts an upper and lower range, use a colon ':' or
+ minus '-' to separate such values. See irange.
+
bool Boolean. Usually parsed as an integer, however only defined for
true and false (1 and 0).
irange Integer range with suffix. Allows value range to be given, such
1k:4k. If the option allows two sets of ranges, they can be
specified with a ',' or '/' delimiter: 1k-4k/8k-32k. Also see
int.
-float_list A list of floating numbers, separated by a ':' character.
+float_list A list of floating point numbers, separated by a ':' character.
With the above in mind, here follows the complete list of fio job
parameters.
read Sequential reads
write Sequential writes
+ trim Sequential trims
randwrite Random writes
randread Random reads
+ randtrim Random trims
rw,readwrite Sequential mixed reads and writes
randrw Random mixed reads and writes
- trimwrite Mixed trims and writes. Blocks will be
- trimmed first, then written to.
+ trimwrite Sequential trim+write sequences
Fio defaults to read if the option is not specified.
For the mixed io types, the default is to split them 50/50.
the same offset 8 number of times before generating a new
offset.
-kb_base=int The base unit for a kilobyte. The defacto base is 2^10, 1024.
- Storage manufacturers like to use 10^3 or 1000 as a base
- ten unit instead, for obvious reasons. Allow values are
- 1024 or 1000, with 1024 being the default.
+kb_base=int Select the interpretation of unit prefixes in input parameters.
+ 1000 = Inputs comply with IEC 80000-13 and the International
+ System of Units (SI). Use:
+ - power-of-2 values with IEC prefixes (e.g., KiB)
+ - power-of-10 values with SI prefixes (e.g., kB)
+ 1024 = Compatibility mode (default). To avoid breaking
+ old scripts:
+ - power-of-2 values with SI prefixes
+ - power-of-10 values with IEC prefixes
+ See bs= for more details on input parameters.
+
+ Outputs always use correct prefixes. Most outputs include
+ both side-by-side, like:
+ bw=2383.3kB/s (2327.4KiB/s)
+ If only one value is reported, then kb_base selects the
+ one to use:
+ 1000 = SI prefixes
+ 1024 = IEC prefixes
unified_rw_reporting=bool Fio normally reports statistics on a per
- data direction basis, meaning that read, write, and trim are
+ data direction basis, meaning that reads, writes, and trims are
accounted and reported separately. If this option is set,
the fio will sum the results and report them as "mixed"
instead.
on what IO patterns it is likely to issue. Sometimes you
want to test specific IO patterns without telling the
kernel about it, in which case you can disable this option.
- If set, fio will use POSIX_FADV_SEQUENTIAL for sequential
- IO and POSIX_FADV_RANDOM for random IO.
+ The following options are supported:
+
+ sequential Use FADV_SEQUENTIAL
+ random Use FADV_RANDOM
+ 1 Backwards-compatible hint for basing
+ the hint on the fio workload. Will use
+ FADV_SEQUENTIAL for a sequential
+ workload, and FADV_RANDOM for a random
+ workload.
+ 0 Backwards-compatible setting for not
+ issing a fadvise hint.
fadvise_stream=int Notify the kernel what write stream ID to place these
writes under. Only supported on Linux. Note, this option
means that the 'size' option sets both the region and size of
IO to be performed. Sometimes that is not what you want. With
this option, it is possible to define just the amount of IO
- that fio should do. For instance, if 'size' is set to 20G and
- 'io_size' is set to 5G, fio will perform IO within the first
- 20G but exit when 5G have been done. The opposite is also
- possible - if 'size' is set to 20G, and 'io_size' is set to
- 40G, then fio will do 40G of IO within the 0..20G region.
+ that fio should do. For instance, if 'size' is set to 20GiB and
+ 'io_size' is set to 5GiB, fio will perform IO within the first
+ 20GiB but exit when 5GiB have been done. The opposite is also
+ possible - if 'size' is set to 20GiB, and 'io_size' is set to
+ 40GiB, then fio will do 40GiB of IO within the 0..20GiB region.
filesize=int Individual file sizes. May be a range, in which case fio
will select sizes for files at random within the given range
Additionally, writing beyond end-of-device will not return
ENOSPC there.
-blocksize=int
-bs=int The block size used for the io units. Defaults to 4k. Values
- can be given for both read and writes. If a single int is
- given, it will apply to both. If a second int is specified
- after a comma, it will apply to writes only. In other words,
- the format is either bs=read_and_write or bs=read,write,trim.
- bs=4k,8k will thus use 4k blocks for reads, 8k blocks for
- writes, and 8k for trims. You can terminate the list with
- a trailing comma. bs=4k,8k, would use the default value for
- trims.. If you only wish to set the write size, you
- can do so by passing an empty read size - bs=,8k will set
- 8k for writes and leave the read default value.
-
-blockalign=int
-ba=int At what boundary to align random IO offsets. Defaults to
- the same as 'blocksize' the minimum blocksize given.
- Minimum alignment is typically 512b for using direct IO,
- though it usually depends on the hardware block size. This
- option is mutually exclusive with using a random map for
- files, so it will turn off that option.
-
-blocksize_range=irange
-bsrange=irange Instead of giving a single block size, specify a range
- and fio will mix the issued io block sizes. The issued
- io unit will always be a multiple of the minimum value
- given (also see bs_unaligned). Applies to both reads and
- writes, however a second range can be given after a comma.
- See bs=.
-
-bssplit=str Sometimes you want even finer grained control of the
+blocksize=int[,int][,int]
+bs=int[,int][,int]
+ The block size in bytes used for I/O units. Default: 4096.
+ A single value applies to reads, writes, and trims.
+ Comma-separated values may be specified for reads, writes,
+ and trims. A value not terminated in a comma applies to
+ subsequent types.
+
+ Examples:
+ bs=256k means 256k for reads, writes and trims
+ bs=8k,32k means 8k for reads, 32k for writes and trims
+ bs=8k,32k, means 8k for reads, 32k for writes, and
+ default for trims
+ bs=,8k means default for reads, 8k for writes and trims
+ bs=,8k, means default for reads, 8k for writes, and
+ default for writes
+
+blocksize_range=irange[,irange][,irange]
+bsrange=irange[,irange][,irange]
+ A range of block sizes in bytes for I/O units.
+ The issued I/O unit will always be a multiple of the minimum
+ size, unless blocksize_unaligned is set.
+
+ Comma-separated ranges may be specified for reads, writes,
+ and trims as described in 'blocksize'.
+
+ Example: bsrange=1k-4k,2k-8k
+
+bssplit=str[,str][,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
always add up to 100, if bssplit is given a range that adds
up to more, it will error out.
- bssplit also supports giving separate splits to reads and
- writes. The format is identical to what bs= accepts. You
- have to separate the read and write parts with a comma. So
- if you want a workload that has 50% 2k reads and 50% 4k reads,
+ Comma-separated values may be specified for reads, writes,
+ and trims as described in 'blocksize'.
+
+ If you want a workload that has 50% 2k reads and 50% 4k reads,
while having 90% 4k writes and 10% 8k writes, you would
specify:
bssplit=2k/50:4k/50,4k/90:8k/10
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
- direct IO, as that normally requires sector alignment.
+bs_unaligned If set, fio will issue I/O units with any size within
+ blocksize_range, not just multiples of the minimum size.
+ This typically won't work with direct I/O, as that normally
+ requires sector alignment.
bs_is_seq_rand If this option is set, fio will use the normal read,write
- blocksize settings as sequential,random instead. Any random
- read or write will use the WRITE blocksize settings, and any
- sequential read or write will use the READ blocksize setting.
+ blocksize settings as sequential,random blocksize settings
+ instead. Any random read or write will use the WRITE blocksize
+ settings, and any sequential read or write will use the READ
+ blocksize settings.
+
+blockalign=int[,int][,int]
+ba=int[,int][,int]
+ Boundary to which fio will align random I/O units.
+ Default: 'blocksize'.
+ Minimum alignment is typically 512b for using direct IO,
+ though it usually depends on the hardware block size. This
+ option is mutually exclusive with using a random map for
+ files, so it will turn off that option.
+ Comma-separated values may be specified for reads, writes,
+ and trims as described in 'blocksize'.
zero_buffers If this option is given, fio will init the IO buffers to
all zeroes. The default is to fill them with random data.
cannot be modified. So random writes are not
possible. To imitate this, libhdfs engine
creates bunch of small files, and engine will
- pick a file out of those files based on the
- offset enerated by fio backend. Each jobs uses
+ pick a file out of those files based on the
+ offset generated by fio backend. Each jobs uses
it's own connection to HDFS.
mtd Read, write and erase an MTD character device
pmemblk Read and write through the NVML libpmemblk
interface.
+ dev-dax Read and write through a DAX device exposed
+ from persistent memory.
+
external Prefix to specify loading an external
IO engine object file. Append the engine
filename, eg ioengine=external:/tmp/foo.o
to load ioengine foo.o in /tmp.
-iodepth=int This defines how many io units to keep in flight against
+iodepth=int This defines how many I/O units to keep in flight against
the file. The default is 1 for each file defined in this
job, can be overridden with a larger value for higher
concurrency. Note that increasing iodepth beyond 1 will not
iodepth_batch_complete_min=1
iodepth_batch_complete_max=<iodepth>
- which means that we will retrieve at leat 1 IO and up to the
+ which means that we will retrieve at least 1 IO and up to the
whole submitted queue depth. If none of IO has been completed
yet, we will wait.
if fio is asked to limit reads or writes to a certain rate.
If that is the case, then the distribution may be skewed.
-random_distribution=str:float By default, fio will use a completely uniform
+random_distribution=str:float[,str:float][,str:float]
+ By default, fio will use a completely uniform
random distribution when asked to perform random IO. Sometimes
it is useful to skew the distribution in specific ways,
ensuring that some parts of the data is more hot than others.
random Uniform random distribution
zipf Zipf distribution
pareto Pareto distribution
- gauss Normal (guassian) distribution
+ gauss Normal (gaussian) distribution
zoned Zoned random distribution
When using a zipf or pareto distribution, an input value
specify separate zones for reads, writes, and trims. If just
one set is given, it'll apply to all of them.
-percentage_random=int For a random workload, set how big a percentage should
+percentage_random=int[,int][,int]
+ For a random workload, set how big a percentage should
be random. This defaults to 100%, in which case the workload
is fully random. It can be set from anywhere from 0 to 100.
Setting it to 0 would make the workload fully sequential. Any
setting in between will result in a random mix of sequential
- and random IO, at the given percentages. It is possible to
- set different values for reads, writes, and trim. To do so,
- simply use a comma separated list. See blocksize.
-
+ and random IO, at the given percentages.
+ Comma-separated values may be specified for reads, writes,
+ and trims as described in 'blocksize'.
+
norandommap Normally fio will cover every block of the file when doing
random IO. If this option is given, fio will just get a
new random offset without looking at past io history. This
nice=int Run the job with the given nice value. See man nice(2).
+ On Windows, values less than -15 set the process class to "High";
+ -1 through -15 set "Above Normal"; 1 through 15 "Below Normal";
+ and above 15 "Idle" priority class.
+
prio=int Set the io priority value of this job. Linux limits us to
a positive value between 0 and 7, with 0 being the highest.
See man ionice(1). Refer to an appropriate manpage for
other words, this setting effectively caps the queue depth
if the latter is larger.
-rate=int Cap the bandwidth used by this job. The number is in bytes/sec,
- the normal suffix rules apply. You can use rate=500k to limit
- reads and writes to 500k each, or you can specify read and
- writes separately. Using rate=1m,500k would limit reads to
- 1MB/sec and writes to 500KB/sec. Capping only reads or
- writes can be done with rate=,500k or rate=500k,. The former
- will only limit writes (to 500KB/sec), the latter will only
- limit reads.
-
-rate_min=int Tell fio to do whatever it can to maintain at least this
- bandwidth. Failing to meet this requirement, will cause
- the job to exit. The same format as rate is used for
- read vs write separation.
-
-rate_iops=int Cap the bandwidth to this number of IOPS. Basically the same
+rate=int[,int][,int]
+ Cap the bandwidth used by this job. The number is in bytes/sec,
+ the normal suffix rules apply.
+ Comma-separated values may be specified for reads, writes,
+ and trims as described in 'blocksize'.
+
+rate_min=int[,int][,int]
+ Tell fio to do whatever it can to maintain at least this
+ bandwidth. Failing to meet this requirement will cause
+ the job to exit.
+ Comma-separated values may be specified for reads, writes,
+ and trims as described in 'blocksize'.
+
+rate_iops=int[,int][,int]
+ Cap the bandwidth to this number of IOPS. Basically the same
as rate, just specified independently of bandwidth. If the
job is given a block size range instead of a fixed value,
- the smallest block size is used as the metric. The same format
- as rate is used for read vs write separation.
+ the smallest block size is used as the metric.
+ Comma-separated values may be specified for reads, writes,
+ and trims as described in 'blocksize'.
-rate_iops_min=int If fio doesn't meet this rate of IO, it will cause
- the job to exit. The same format as rate is used for read vs
- write separation.
+rate_iops_min=int[,int][,int]
+ If fio doesn't meet this rate of IO, it will cause
+ the job to exit.
+ Comma-separated values may be specified for reads, writes,
+ and trims as described in 'blocksize'.
rate_process=str This option controls how fio manages rated IO
submissions. The default is 'linear', which submits IO in a
one cpu per job. If not enough CPUs are given for the jobs
listed, then fio will roundrobin the CPUs in the set.
-numa_cpu_nodes=str Set this job running on spcified NUMA nodes' CPUs. The
+numa_cpu_nodes=str Set this job running on specified NUMA nodes' CPUs. The
arguments allow comma delimited list of cpu numbers,
A-B ranges, or 'all'. Note, to enable numa options support,
fio must be built on a system with libnuma-dev(el) installed.
numa_mem_policy=str Set this job's memory policy and corresponding NUMA
- nodes. Format of the argements:
+ nodes. Format of the arguments:
<mode>[:<nodelist>]
`mode' is one of the following memory policy:
default, prefer, bind, interleave, local
thus it will increase the total runtime if a special timeout
or runtime is specified.
+steadystate=str:float
+ss=str:float Define the criterion and limit for assessing steady state
+ performance. The first parameter designates the criterion
+ whereas the second parameter sets the threshold. When the
+ criterion falls below the threshold for the specified duration,
+ the job will stop. For example, iops_slope:0.1% will direct fio
+ to terminate the job when the least squares regression slope
+ falls below 0.1% of the mean IOPS. If group_reporting is
+ enabled this will apply to all jobs in the group. Below is the
+ list of available steady state assessment criteria. All
+ assessments are carried out using only data from the rolling
+ collection window. Threshold limits can be expressed as a fixed
+ value or as a percentage of the mean in the collection window.
+ iops Collect IOPS data. Stop the job if all
+ individual IOPS measurements are within the
+ specified limit of the mean IOPS (e.g., iops:2
+ means that all individual IOPS values must be
+ within 2 of the mean, whereas iops:0.2% means
+ that all individual IOPS values must be within
+ 0.2% of the mean IOPS to terminate the job).
+ iops_slope
+ Collect IOPS data and calculate the least
+ squares regression slope. Stop the job if the
+ slope falls below the specified limit.
+ bw Collect bandwidth data. Stop the job if all
+ individual bandwidth measurements are within
+ the specified limit of the mean bandwidth.
+ bw_slope
+ Collect bandwidth data and calculate the least
+ squares regression slope. Stop the job if the
+ slope falls below the specified limit.
+
+steadystate_duration=time
+ss_dur=time A rolling window of this duration will be used to judge whether
+ steady state has been reached. Data will be collected once per
+ second. The default is 0 which disables steady state detection.
+
+steadystate_ramp_time=time
+ss_ramp=time Allow the job to run for the specified duration before
+ beginning data collection for checking the steady state job
+ termination criterion. The default is 0.
+
invalidate=bool Invalidate the buffer/page cache parts for this file prior
to starting io. Defaults to true.
io engines, this means using O_SYNC.
iomem=str
-mem=str Fio can use various types of memory as the io unit buffer.
+mem=str Fio can use various types of memory as the I/O unit buffer.
The allowed values are:
malloc Use memory from malloc(3) as the buffers.
that for shmhuge and mmaphuge to work, the system must have
free huge pages allocated. This can normally be checked
and set by reading/writing /proc/sys/vm/nr_hugepages on a
- Linux system. Fio assumes a huge page is 4MB in size. So
+ Linux system. Fio assumes a huge page is 4MiB in size. So
to calculate the number of huge pages you need for a given
job file, add up the io depth of all jobs (normally one unless
iodepth= is used) and multiply by the maximum bs set. Then
location should point there. So if it's mounted in /huge,
you would use mem=mmaphuge:/huge/somefile.
-iomem_align=int This indiciates the memory alignment of the IO memory buffers.
- Note that the given alignment is applied to the first IO unit
+iomem_align=int This indicates the memory alignment of the IO memory buffers.
+ Note that the given alignment is applied to the first I/O 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
hugepage-size=int
Defines the size of a huge page. Must at least be equal
- to the system setting, see /proc/meminfo. Defaults to 4MB.
+ to the system setting, see /proc/meminfo. Defaults to 4MiB.
Should probably always be a multiple of megabytes, so using
hugepage-size=Xm is the preferred way to set this to avoid
setting a non-pow-2 bad value.
through 'write_iops_log', then the minimum of this option and
'log_avg_msec' will be used. Default: 500ms.
-create_serialize=bool If true, serialize the file creating for the jobs.
+create_serialize=bool If true, serialize the file creation for the jobs.
This may be handy to avoid interleaving of data
files, which may greatly depend on the filesystem
used and even the number of processors in the system.
starting the given IO operation. This will also clear
the 'invalidate' flag, since it is pointless to pre-read
and then drop the cache. This will only work for IO engines
- that are seekable, since they allow you to read the same data
+ that are seek-able, since they allow you to read the same data
multiple times. Thus it will not work on eg network or splice
IO.
runs of that job would then waste time recreating the file
set again and again.
+unlink_each_loop=bool Unlink job files after each iteration or loop.
+
loops=int Run the specified number of iterations of this job. Used
to repeat the same workload a given number of times. Defaults
to 1.
crc32c Use a crc32c sum of the data area and store
it in the header of each block.
- crc32c-intel Use hardware assisted crc32c calcuation
+ crc32c-intel Use hardware assisted crc32c calculation
provided on SSE4.2 enabled processors. Falls
back to regular software crc32c, if not
supported by the system.
+ crc32c-arm64 Use hardware assisted crc32c calculation
+ provided on CRC enabled ARM 64-bits processors.
+ Falls back to regular software crc32c, if not
+ supported by the system.
+
crc32 Use a crc32 sum of the data area and store
it in the header of each block.
be a hex number that starts with either "0x" or "0X". Use
with verify=str. Also, verify_pattern supports %o format,
which means that for each block offset will be written and
- then verifyied back, e.g.:
+ then verified back, e.g.:
verify_pattern=%o
replay_no_stall=int When replaying I/O with read_iolog the default behavior
is to attempt to respect the time stamps within the log and
- replay them with the appropriate delay between IOPS. By
+ replay them with the appropriate delay between IOPS. By
setting this variable fio will not respect the timestamps and
attempt to replay them as fast as possible while still
- respecting ordering. The result is the same I/O pattern to a
+ respecting ordering. The result is the same I/O pattern to a
given device, but different timings.
replay_redirect=str While replaying I/O patterns using read_iolog the
mapping. Replay_redirect causes all IOPS to be replayed onto
the single specified device regardless of the device it was
recorded from. i.e. replay_redirect=/dev/sdc would cause all
- IO in the blktrace to be replayed onto /dev/sdc. This means
- multiple devices will be replayed onto a single, if the trace
- contains multiple devices. If you want multiple devices to be
- replayed concurrently to multiple redirected devices you must
- blkparse your trace into separate traces and replay them with
- independent fio invocations. Unfortuantely this also breaks
- the strict time ordering between multiple device accesses.
+ IO in the blktrace or iolog to be replayed onto /dev/sdc.
+ This means multiple devices will be replayed onto a single
+ device, if the trace contains multiple devices. If you want
+ multiple devices to be replayed concurrently to multiple
+ redirected devices you must blkparse your trace into separate
+ traces and replay them with independent fio invocations.
+ Unfortunately this also breaks the strict time ordering
+ between multiple device accesses.
replay_align=int Force alignment of IO offsets and lengths in a trace
to this power of 2 value.
The actual log names will be foo_slat.x.log, foo_clat.x.log,
and foo_lat.x.log, where x is the index of the job (1..N,
where N is the number of jobs). This helps fio_generate_plot
- fine the logs automatically. If 'per_job_logs' is false, then
+ find the logs automatically. If 'per_job_logs' is false, then
the filename will not include the job index. See 'Log File
Formats'.
+write_hist_log=str Same as write_lat_log, but writes I/O completion
+ latency histograms. If no filename is given with this option, the
+ default filename of "jobname_clat_hist.x.log" is used, where x is
+ the index of the job (1..N, where N is the number of jobs). Even
+ if the filename is given, fio will still append the type of log.
+ If per_job_logs is false, then the filename will not include the
+ job index. See 'Log File Formats'.
+
write_iops_log=str Same as write_bw_log, but writes IOPS. If no filename is
given with this option, the default filename of
"jobname_type.x.log" is used,where x is the index of the job
specified period of time, reducing the resolution of the log.
See log_max_value as well. Defaults to 0, logging all entries.
+log_hist_msec=int Same as log_avg_msec, but logs entries for completion
+ latency histograms. Computing latency percentiles from averages of
+ intervals using log_avg_msec is innacurate. Setting this option makes
+ fio log histogram entries over the specified period of time, reducing
+ log sizes for high IOPS devices while retaining percentile accuracy.
+ See log_hist_coarseness as well. Defaults to 0, meaning histogram
+ logging is disabled.
+
+log_hist_coarseness=int Integer ranging from 0 to 6, defining the coarseness
+ of the resolution of the histogram logs enabled with log_hist_msec. For
+ each increment in coarseness, fio outputs half as many bins. Defaults to
+ 0, for which histogram logs contain 1216 latency bins. See
+ 'Log File Formats'.
+
log_max_value=bool If log_avg_msec is set, fio logs the average over that
window. If you instead want to log the maximum value, set this
option to 1. Defaults to 0, meaning that averaged values are
the --inflate-log command line parameter. The files will be
stored with a .fz suffix.
+log_unix_epoch=bool If set, fio will log Unix timestamps to the log
+ files produced by enabling write_type_log for each log type, instead
+ of the default zero-based timestamps.
+
block_error_percentiles=bool If set, record errors in trim block-sized
units from writes and trims and output a histogram of
how many trims it took to get to errors, and what kind
connections rather than initiating an outgoing connection. The
hostname must be omitted if this option is used.
-[net] pingpong Normaly a network writer will just continue writing data, and
+[net] pingpong Normally a network writer will just continue writing data, and
a network reader will just consume packages. If pingpong=1
is set, a writer will send its normal payload to the reader,
then wait for the reader to send the same payload back. This
[e4defrag] inplace=int
Configure donor file blocks allocation strategy
0(default): Preallocate donor's file on init
- 1 : allocate space immidietly inside defragment event,
+ 1 : allocate space immediately inside defragment event,
and free right after event
[rbd] clustername=str Specifies the name of the Ceph cluster.
[rbd] rbdname=str Specifies the name of the RBD.
-[rbd] pool=str Specifies the naem of the Ceph pool containing RBD.
+[rbd] pool=str Specifies the name of the Ceph pool containing RBD.
[rbd] clientname=str Specifies the username (without the 'client.' prefix)
used to access the Ceph cluster. If the clustername is
- specified, the clientmae shall be the full type.id
+ specified, the clientname shall be the full type.id
string. If no type. prefix is given, fio will add
'client.' by default.
[mtd] skip_bad=bool Skip operations against known bad blocks.
[libhdfs] hdfsdirectory libhdfs will create chunk in this HDFS directory
-[libhdfs] chunck_size the size of the chunck to use for each file.
+[libhdfs] chunk_size the size of the chunk to use for each file.
6.0 Interpreting the output
fio spits out a lot of output. While running, fio will display the
status of the jobs created. An example of that would be:
-Threads: 1: [_r] [24.8% done] [ 13509/ 8334 kb/s] [eta 00h:01m:31s]
+Jobs: 1: [_r] [24.8% done] [r=20992KiB/s,w=24064KiB/s,t=0KiB/s] [r=82,w=94,t=0 iops] [eta 00h:01m:31s]
The characters inside the square brackets denote the current status of
each thread. The possible values (in typical life cycle order) are:
command line as is needed. For instance, if you have 10 readers and 10
writers running, the output would look like this:
-Jobs: 20 (f=20): [R(10),W(10)] [4.0% done] [2103MB/0KB/0KB /s] [538K/0/0 iops] [eta 57m:36s]
+Jobs: 20 (f=20): [R(10),W(10)] [4.0% done] [r=20992KiB/s,w=24064KiB/s,t=0KiB/s] [r=82,w=94,t=0 iops] [eta 57m:36s]
Fio will still maintain the ordering, though. So the above means that jobs
1..10 are readers, and 11..20 are writers.
direction, the output looks like:
Client1 (g=0): err= 0:
- write: io= 32MB, bw= 666KB/s, iops=89 , runt= 50320msec
+ write: io= 32MiB, bw= 666KiB/s, iops=89 , runt= 50320msec
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 (KB/s) : min= 0, max= 1196, per=51.00%, avg=664.02, stdev=681.68
+ 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, 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%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
terse version, fio version, jobname, groupid, error
READ status:
- Total IO (KB), bandwidth (KB/sec), IOPS, runtime (msec)
+ Total IO (KiB), bandwidth (KiB/sec), IOPS, runtime (msec)
Submission latency: min, max, mean, stdev (usec)
Completion latency: min, max, mean, stdev (usec)
Completion latency percentiles: 20 fields (see below)
Total latency: min, max, mean, stdev (usec)
- Bw (KB/s): min, max, aggregate percentage of total, mean, stdev
+ Bw (KiB/s): min, max, aggregate percentage of total, mean, stdev
WRITE status:
- Total IO (KB), bandwidth (KB/sec), IOPS, runtime (msec)
+ Total IO (KiB), bandwidth (KiB/sec), IOPS, runtime (msec)
Submission latency: min, max, mean, stdev (usec)
Completion latency: min, max, mean, stdev(usec)
Completion latency percentiles: 20 fields (see below)
Total latency: min, max, mean, stdev (usec)
- Bw (KB/s): min, max, aggregate percentage of total, mean, stdev
+ Bw (KiB/s): min, max, aggregate percentage of total, mean, stdev
CPU usage: user, system, context switches, major faults, minor faults
IO depths: <=1, 2, 4, 8, 16, 32, >=64
IO latencies microseconds: <=2, 4, 10, 20, 50, 100, 250, 500, 750, 1000
on the type of log, it will be one of the following:
Latency log Value is latency in usecs
- Bandwidth log Value is in KB/sec
+ Bandwidth log Value is in KiB/sec
IOPS log Value is IOPS
Data direction is one of the following:
The offset is the offset, in bytes, from the start of the file, for that
particular IO. The logging of the offset can be toggled with 'log_offset'.
-If windowed logging is enabled though 'log_avg_msec', then fio doesn't log
+If windowed logging is enabled through 'log_avg_msec', then fio doesn't log
individual IOs. Instead of logs the average values over the specified
period of time. Since 'data direction' and 'offset' are per-IO values,
they aren't applicable if windowed logging is enabled. If windowed logging
is enabled and 'log_max_value' is set, then fio logs maximum values in
that window instead of averages.
-