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
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.
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
(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.
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