dump this text description when this job is run. It's
not parsed.
-directory=str Prefix filenames with this directory. Used to places files
+directory=str Prefix filenames with this directory. Used to place files
in a different location than "./".
filename=str Fio normally makes up a filename based on the job name,
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
+lockfile=str Fio defaults to not locking any 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
size=int The total size of file io for this job. Fio will run until
this many bytes has been transferred, unless runtime is
limited by other options (such as 'runtime', for instance).
- Unless specific nr_files and filesize options are given,
+ Unless specific nrfiles and filesize options are given,
fio will divide this size between the available files
specified by the job.
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.
+ sense with sequential write. For a read workload, the mount
+ point will be filled first then IO started on the result.
blocksize=int
bs=int The block size used for the io units. Defaults to 4k. Values
rwmixwrite=int How large a percentage of the mix should be writes. If both
rwmixread and rwmixwrite is given and the values do not add
up to 100%, the latter of the two will be used to override
- the first.
+ the first. This may interfere with a given rate setting,
+ if fio is asked to limit reads or writes to a certain rate.
+ If that is the case, then the distribution may be skewed.
norandommap Normally fio will cover every block of the file when doing
random IO. If this option is given, fio will just get a
defaults to 1 which will make fio wait 'thinktime' usecs
after every block.
-rate=int Cap the bandwidth used by this job to this number of KiB/sec.
+rate=int Cap the bandwidth used by this job. The number is in bytes/sec,
+ the normal postfix 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.
ratemin=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 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
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 smallest block size is used as the metric. The same format
+ as rate is used for read vs write seperation.
rate_iops_min=int If fio doesn't meet this rate of IO, it will cause
- the job to exit.
+ the job to exit. The same format as rate is used for read vs
+ write seperation.
ratecycle=int Average bandwidth for 'rate' and 'ratemin' over this number
of milliseconds.
create_on_open=bool Don't pre-setup the files for IO, just create open()
when it's time to do IO to that file.
+pre_read=bool If this is given, files will be pre-read into memory before
+ starting the given IO operation. This will also clear
+ the 'invalidate' flag, since it is pointless to pre-read
+ and then drop the cache.
+
unlink=bool Unlink the job files when done. Not the default, as repeated
runs of that job would then waste time recreating the file
set again and again.
P Thread setup, but not started.
C Thread created.
I Thread initialized, waiting.
+ p Thread running pre-reading file(s).
R Running, doing sequential reads.
r Running, doing random reads.
W Running, doing sequential writes.