and it will start doing what the job_file tells it to do. You can give
more than one job file on the command line, fio will serialize the running
of those files. Internally that is the same as using the 'stonewall'
-parameter described the the parameter section.
+parameter described in the parameter section.
If the job file contains only one job, you may as well just give the
parameters on the command line. The command line parameters are identical
Unless specific nrfiles and filesize options are given,
fio will divide this size between the available files
specified by the job. If not set, fio will use the full
- size of the given files or devices. If the the files
- do not exist, size must be given. It is also possible to
- give size as a percentage between 1 and 100. If size=20%
- is given, fio will use 20% of the full size of the given
+ size of the given files or devices. If the files do not
+ exist, size must be given. It is also possible to give
+ size as a percentage between 1 and 100. If size=20% is
+ given, fio will use 20% of the full size of the given
files or devices.
+io_limit=int Normally fio operates within the region set by 'size', which
+ 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_limit' is set to 5G, fio will perform IO within the first
+ 20G but exit when 5G have been done.
+
filesize=int Individual file sizes. May be a range, in which case fio
will select sizes for files at random within the given range
and limited to 'size' in total (if that is given). If not
given, each created file is the same size.
+file_append=bool Perform IO after the end of the file. Normally fio will
+ operate within the size of a file. If this option is set, then
+ fio will append to the file instead. This has identical
+ behavior to setting offset to the size of a file. This option
+ is ignored on non-regular files.
+
fill_device=bool
fill_fs=bool Sets size to something really large and waits for ENOSPC (no
space left on device) as the terminating condition. Only makes
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.
+ The resulting IO buffers will not be completely zeroed,
+ unless scramble_buffers is also turned off.
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
specified period of time, reducing the resolution of the log.
Defaults to 0.
+log_offset=int If this is set, the iolog options will include the byte
+ offset for the IO entry as well as the other data values.
+
lockmem=int Pin down the specified amount of memory with mlock(2). Can
potentially be used instead of removing memory or booting
with less memory to simulate a smaller amount of memory.
[cpu] cpuchunks=int Split the load into cycles of the given time. In
microseconds.
+[cpu] exit_on_io_done=bool Detect when IO threads are done, then exit.
+
[netsplice] hostname=str
[net] hostname=str The host name or IP address to use for TCP or UDP based IO.
If the job is a TCP listener or UDP reader, the hostname is not
M Running, doing mixed sequential reads/writes.
m Running, doing mixed random reads/writes.
F Running, currently waiting for fsync()
+ f Running, finishing up (writing IO logs, etc)
V Running, doing verification of written data.
E Thread exited, not reaped by main thread yet.
_ Thread reaped, or
X Thread reaped, exited with an error.
K Thread reaped, exited due to signal.
+Fio will condense the thread string as not to take up more space on the
+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]
+
+Fio will still maintain the ordering, though. So the above means that jobs
+1..10 are readers, and 11..20 are writers.
+
The other values are fairly self explanatory - number of threads
currently running and doing io, rate of io since last check (read speed
listed first, then write speed), and the estimated completion percentage