str String. This is a sequence of alpha characters.
int Integer. A whole number value, can be negative. If prefixed with
- 0x, the integer is assumed to be of base 16 (hexidecimal).
+ 0x, the integer is assumed to be of base 16 (hexadecimal).
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,
you could either write out '4096' or just give 4k. The postfixes
signify base 2 values, so 1024 is 1k and 1024k is 1m and so on.
If the option accepts an upper and lower range, use a colon ':'
- or minus '-' to seperate such values. See irange.
+ 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 postfix. Allows value range to be given, such
- as 1024-4096. A colon may also be used as the seperator, eg
+ as 1024-4096. A colon may also be used as the separator, eg
1k:4k. If the option allows two sets of ranges, they can be
specified with a ',' or '/' delimiter: 1k-4k/8k-32k. Also see
siint.
the ioengine used is 'net', the filename is the host and
port to connect to in the format of =host/port. If the
ioengine is file based, you can specify a number of files
- by seperating the names with a ':' colon. So if you wanted
+ by separating the names with a ':' colon. So if you wanted
a job to open /dev/sda and /dev/sdb as the two working files,
you would use filename=/dev/sda:/dev/sdb. '-' is a reserved
name, meaning stdin or stdout. Which of the two depends
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
+ the file before giving up the lock. Since lock acquisition is
expensive, batching the lock/unlocks will speed up IO.
readwrite=str
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.
+refill_buffers If this option is given, fio will refill the IO buffers
+ on every submit. The default is to only fill it at init
+ time and reuse that data. Only makes sense if zero_buffers
+ isn't specified, naturally. If data verification is enabled,
+ refill_buffers is also automatically enabled.
+
nrfiles=int Number of files to use for this job. Defaults to 1.
openfiles=int Number of files to keep open at the same time. Defaults to
posixaio glibc posix asynchronous io.
+ solarisaio Solaris native asynchronous io.
+
mmap File is memory mapped and data copied
to/from using memcpy(3).
job, can be overridden with a larger value for higher
concurrency.
+iodepth_batch_submit=int
iodepth_batch=int This defines how many pieces of IO to submit at once.
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_batch_complete=int This defines how many pieces of IO to retrieve
+ at once. It defaults to 1 which means that we'll ask
+ for a minimum of 1 IO in the retrieval process from
+ the kernel. The IO retrieval will go on until we
+ hit the limit set by iodepth_low. If this variable is
+ set to 0, then fio will always check for completed
+ events before queuing more IO. This helps reduce
+ IO latency, at the cost of more retrieval system calls.
+
iodepth_low=int The low water mark indicating when to start filling
the queue again. Defaults to the same as iodepth, meaning
that fio will attempt to keep the queue full at all times.
not sync the file. The exception is the sg io engine, which
synchronizes the disk cache anyway.
-overwrite=bool If writing to a file, setup the file first and do overwrites.
+overwrite=bool If true, writes to a file will always overwrite existing
+ data. If the file doesn't already exist, it will be
+ created before the write phase begins. If the file exists
+ and is large enough for the specified write phase, nothing
+ will be done.
end_fsync=bool If true, fsync file contents when the job exits.
This differs from end_fsync in that it will happen on every
file close, not just at the end of the job.
-rwmixcycle=int Value in milliseconds describing how often to switch between
- reads and writes for a mixed workload. The default is
- 500 msecs.
-
rwmixread=int How large a percentage of the mix should be reads.
rwmixwrite=int How large a percentage of the mix should be writes. If both
fio doesn't track potential block rewrites which may alter
the calculated checksum for that block.
+softrandommap 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.
+
nice=int Run the job with the given nice value. See man nice(2).
prio=int Set the io priority value of this job. Linux limits us to
cap the total runtime to a given time.
time_based If set, fio will run for the duration of the runtime
- specified even if the file(s) are completey read or
+ specified even if the file(s) are completely read or
written. It will simply loop over the same workload
as many times as the runtime allows.
+ramp_time If set, fio will run the specified workload for this amount
+ of time before logging any performance numbers. Useful for
+ letting performance settle before logging results, thus
+ minimizing the runtime required for stable results.
+
invalidate=bool Invalidate the buffer/page cache parts for this file prior
to starting io. Defaults to true.
default.
unlink=bool Unlink the job files when done. Not the default, as repeated
- runs of that job would then waste time recreating the fileset
- again and again.
+ runs of that job would then waste time recreating the file
+ set again and again.
loops=int Run the specified number of iterations of this job. Used
to repeat the same workload a given number of times. Defaults
area and store it in the header of each
block.
+ 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
+ provided on SSE4.2 enabled processors.
+
crc32 Use a crc32 sum of the data area and store
it in the header of each block.
new_group Start a new reporting group. If this option isn't given,
jobs in a file will be part of the same reporting group
- unless seperated by a stone wall (or if it's a group
+ unless separated by a stone wall (or if it's a group
by itself, with the numjobs option).
numjobs=int Create the specified number of clones of this job. May be
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%
+ complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=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%,
lat (msec): 250=15.2%, 500=0.0%, 750=0.0%, 1000=0.0%, >=2048=0.0%
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. This
- value can be in miliseconds or microseconds, fio will choose
+ value can be in milliseconds or microseconds, fio will choose
the most appropriate base and print that. In the example
- above, miliseconds is the best scale.
+ above, milliseconds 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,
16= entries includes depths up to that value but higher
than the previous entry. In other words, it covers the
range from 16 to 31.
+IO submit= How many pieces of IO were submitting in a single submit
+ call. Each entry denotes that amount and below, until
+ the previous entry - eg, 8=100% mean that we submitted
+ anywhere in between 5-8 ios per submit call.
+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= The distribution of IO completion latencies. This is the
projects / fio.git / blobdiff