fio resides in a git repo, the canonical place is:
-git://brick.kernel.dk/data/git/fio.git
+git://git.kernel.dk/fio.git
+
+The http protocol also works, path is the same.
Snapshots are frequently generated and they include the git meta data as
well. You can download them here:
http://brick.kernel.dk/snaps/
-Pascal Bleser <guru@unixtech.be> has fio RPMs in his repository, you
-can find them here:
+Pascal Bleser <guru@unixtech.be> has fio RPMs in his repository for
+SUSE variants, you can find them here:
http://linux01.gwdg.de/~pbleser/rpm-navigation.php?cat=System/fio
+Dag Wieërs has RPMs for Red Hat related distros, find them here:
+
+http://dag.wieers.com/rpm/packages/fio/
+
+Mandriva has integrated fio into their package repository, so installing
+on that distro should be as easy as typing 'urpmi fio'.
+
+
+Mailing list
+------------
+
+There's a mailing list associated with fio. It's meant for general
+discussion, bug reporting, questions - basically anything that has to
+do with fio. An automated mail detailing recent commits is automatically
+sent to the list at most daily. The list address is fio-devel@kernel.dk,
+subscribe by sending an empty email to fio-devel+subscribe@kernel.dk.
+
Building
--------
------------
$ fio
- -t <sec> Runtime in seconds
- -l Generate per-job latency logs
- -w Generate per-job bandwidth logs
- -o <file> Log output to file
- -m Minimal (terse) output
- -h Print help info
- -v Print version information and exit
-
-Any parameters following the options will be assumed to be job files.
-You can add as many as you want, each job file will be regarded as a
-separate group and fio will stonewall it's execution.
+ --debug Enable some debugging options (see below)
+ --output Write output to file
+ --timeout Runtime in seconds
+ --latency-log Generate per-job latency logs
+ --bandwidth-log Generate per-job bandwidth logs
+ --minimal Minimal (terse) output
+ --version Print version info and exit
+ --help Print this page
+ --cmdhelp=cmd Print command help, "all" for all of them
+ --showcmd Turn a job file into command line options
+ --readonly Turn on safety read-only checks, preventing writes
+ --eta=when When ETA estimate should be printed
+ May be "always", "never" or "auto"
+ --section=name Only run specified section in job file
+
+
+Any parameters following the options will be assumed to be job files,
+unless they match a job file parameter. You can add as many as you want,
+each job file will be regarded as a separate group and fio will stonewall
+its execution.
+
+The --readonly switch is an extra safety guard to prevent accidentically
+turning on a write setting when that is not desired. Fio will only write
+if rw=write/randwrite/rw/randrw is given, but this extra safety net can
+be used as an extra precaution. It will also enable a write check in the
+io engine core to prevent an accidental write due to a fio bug.
+
+The debug switch allows adding options that trigger certain logging
+options in fio. Currently the options are:
+
+ process Dump info related to processes
+ file Dump info related to file actions
+ io Dump info related to IO queuing
+ mem Dump info related to memory allocations
+ blktrace Dump info related to blktrace setup
+ verify Dump info related to IO verification
+ all Enable all debug options
+ random Dump info related to random offset generation
+ ? or help Show available debug options.
+
+You can specify as many as you want, eg --debug=file,mem will enable
+file and memory debugging.
+
+The section switch is meant to make it easier to ship a bigger job file
+instead of several smaller ones. Say you define a job file with light,
+moderate, and heavy parts. Then you can ask fio to run the given part
+only by giving it a --section=heavy command line option. The section
+option only applies to job sections, the reserved 'global' section is
+always parsed and taken into account.
Job file
--------
-Only a few options can be controlled with command line parameters,
-generally it's a lot easier to just write a simple job file to describe
-the workload. The job file format is in the ini style format, as it's
-easy to read and write for the user.
+See the HOWTO file for a more detailed description of parameters and what
+they mean. This file contains the terse version. You can describe big and
+complex setups with the command line, but generally it's a lot easier to
+just write a simple job file to describe the workload. The job file format
+is in the ini style format, as that is easy to read and write for the user.
The job file parameters are:
name=x Use 'x' as the identifier for this job.
+ description=x 'x' is a text description of the job.
directory=x Use 'x' as the top level directory for storing files
filename=x Force the use of 'x' as the filename for all files
in this thread. If not given, fio will make up
size=x Set file size to x bytes (x string can include k/m/g)
ioengine=x 'x' may be: aio/libaio/linuxaio for Linux aio,
posixaio for POSIX aio, sync for regular read/write io,
- mmap for mmap'ed io, splice for using splice/vmsplice,
- or sgio for direct SG_IO io. The latter only works on
- Linux on SCSI (or SCSI-like devices, such as
- usb-storage or sata/libata driven) devices.
+ psync for regular pread/pwrite io, vsync for regular
+ readv/writev (with queuing emulation) mmap for mmap'ed
+ io, syslet-rw for syslet driven read/write, splice for
+ using splice/vmsplice, sgio for direct SG_IO io, net
+ for network io, or cpuio for a cycler burner load. sgio
+ only works on Linux on SCSI (or SCSI-like devices, such
+ as usb-storage or sata/libata driven) devices. Fio also
+ has a null io engine, which is mainly used for testing
+ fio itself.
+
iodepth=x For async io, allow 'x' ios in flight
overwrite=x If 'x', layout a write file first.
nrfiles=x Spread io load over 'x' number of files per job,
ratemin=x Quit if rate of x KiB/sec can't be met
ratecycle=x ratemin averaged over x msecs
cpumask=x Only allow job to run on CPUs defined by mask.
+ cpus_allowed=x Like 'cpumask', but allow text setting of CPU affinity.
fsync=x If writing with buffered IO, fsync after every
'x' blocks have been written.
end_fsync=x If 'x', run fsync() after end-of-job.
startdelay=x Start this thread x seconds after startup
- timeout=x Terminate x seconds after startup. Can include a
+ runtime=x Terminate x seconds after startup. Can include a
normal time suffix if not given in seconds, such as
'm' for minutes, 'h' for hours, and 'd' for days.
offset=x Start io at offset x (x string can include k/m/g)
ioscheduler=x Use ioscheduler 'x' for this job.
cpuload=x For a CPU io thread, percentage of CPU time to attempt
to burn.
- cpuchunks=x Split burn cycles into pieces of x.
-
-
-Examples using a job file
--------------------------
-
-Example 1) Two random readers
-
-Lets say we want to simulate two threads reading randomly from a file
-each. They will be doing IO in 4KiB chunks, using raw (O_DIRECT) IO.
-Since they share most parameters, we'll put those in the [global]
-section. Job 1 will use a 128MiB file, job 2 will use a 256MiB file.
-
-; ---snip---
-
-[global]
-ioengine=sync ; regular read/write(2), the default
-rw=randread
-bs=4k
-direct=1
-
-[file1]
-size=128m
-
-[file2]
-size=256m
-
-; ---snip---
-
-Generally the [] bracketed name specifies a file name, but the "global"
-keyword is reserved for setting options that are inherited by each
-subsequent job description. It's possible to have several [global]
-sections in the job file, each one adds options that are inherited by
-jobs defined below it. The name can also point to a block device, such
-as /dev/sda. To run the above job file, simply do:
-
-$ fio jobfile
-
-Example 2) Many random writers
-
-Say we want to exercise the IO subsystem some more. We'll define 64
-threads doing random buffered writes. We'll let each thread use async io
-with a depth of 4 ios in flight. A job file would then look like this:
-
-; ---snip---
-
-[global]
-ioengine=libaio
-iodepth=4
-rw=randwrite
-bs=32k
-direct=0
-size=64m
-
-[files]
-numjobs=64
-
-; ---snip---
-
-This will create files.[0-63] and perform the random writes to them.
-
-There are endless ways to define jobs, the examples/ directory contains
-a few more examples.
-
-
-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 running: 1: [_r] [24.79% done] [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:
-
-Idle Run
----- ---
-P Thread setup, but not started.
-C Thread created.
-I Thread initialized, waiting.
- R Running, doing sequential reads.
- r Running, doing random reads.
- W Running, doing sequential writes.
- w Running, doing random writes.
- M Running, doing mixed sequential reads/writes.
- m Running, doing mixed random reads/writes.
- F Running, currently waiting for fsync()
-V Running, doing verification of written data.
-E Thread exited, not reaped by main thread yet.
-_ Thread reaped.
-
-The other values are fairly self explanatory - number of threads
-currently running and doing io, and the estimated completion percentage
-and time for the running group. It's impossible to estimate runtime
-of the following groups (if any).
-
-When fio is done (or interrupted by ctrl-c), it will show the data for
-each thread, group of threads, and disks in that order. For each data
-direction, the output looks like:
-
-Client1 (g=0): err= 0:
- write: io= 32MiB, bw= 666KiB/s, runt= 50320msec
- slat (msec): min= 0, max= 136, avg= 0.03, dev= 1.92
- clat (msec): min= 0, max= 631, avg=48.50, dev=86.82
- bw (KiB/s) : min= 0, max= 1196, per=51.00%, avg=664.02, dev=681.68
- cpu : usr=1.49%, sys=0.25%, ctx=7969
-
-The client number is printed, along with the group id and error of that
-thread. Below is the io statistics, here for writes. In the order listed,
-they denote:
-
-io= Number of megabytes io performed
-bw= Average bandwidth rate
-runt= The runtime of that thread
- slat= Submission latency (avg being the average, dev being the
- 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.
- 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,
- as the time from submit to complete is basically just
- CPU time (io has already been done, see slat explanation).
- bw= Bandwidth. Same names as the xlat stats, but also includes
- an approximate percentage of total aggregate bandwidth
- this thread received in this group. This last value is
- only really useful if the threads in this group are on the
- same disk, since they are then competing for disk access.
-cpu= CPU usage. User and system time, along with the number
- of context switches this thread went through.
-
-After each client has been listed, the group statistics are printed. They
-will look like this:
-
-Run status group 0 (all jobs):
- READ: io=64MiB, aggrb=22178, minb=11355, maxb=11814, mint=2840msec, maxt=2955msec
- WRITE: io=64MiB, aggrb=1302, minb=666, maxb=669, mint=50093msec, maxt=50320msec
-
-For each data direction, it prints:
-
-io= Number of megabytes io performed.
-aggrb= Aggregate bandwidth of threads in this group.
-minb= The minimum average bandwidth a thread saw.
-maxb= The maximum average bandwidth a thread saw.
-mint= The smallest runtime of the threads in that group.
-maxt= The longest runtime of the threads in that group.
-
-And finally, the disk statistics are printed. They will look like this:
-
-Disk stats (read/write):
- sda: ios=16398/16511, merge=30/162, ticks=6853/819634, in_queue=826487, util=100.00%
-
-Each value is printed for both reads and writes, with reads first. The
-numbers denote:
-
-ios= Number of ios performed by all groups.
-merge= Number of merges io the io scheduler.
-ticks= Number of ticks we kept the disk busy.
-io_queue= Total time spent in the disk queue.
-util= The disk utilization. A value of 100% means we kept the disk
- busy constantly, 50% would be a disk idling half of the time.
-
-
-Terse output
-------------
-
-For scripted usage where you typically want to generate tables or graphs
-of the results, fio can output the results in a comma seperated format.
-The format is one long line of values, such as:
-
-client1,0,0,936,331,2894,0,0,0.000000,0.000000,1,170,22.115385,34.290410,16,714,84.252874%,366.500000,566.417819,3496,1237,2894,0,0,0.000000,0.000000,0,246,6.671625,21.436952,0,2534,55.465300%,1406.600000,2008.044216,0.000000%,0.431928%,1109
-
-Split up, the format is as follows:
-
- jobname, groupid, error
- READ status:
- KiB IO, bandwidth (KiB/sec), runtime (msec)
- Submission latency: min, max, mean, deviation
- Completion latency: min, max, mean, deviation
- Bw: min, max, aggreate percentage of total, mean, deviation
- WRITE status:
- KiB IO, bandwidth (KiB/sec), runtime (msec)
- Submission latency: min, max, mean, deviation
- Completion latency: min, max, mean, deviation
- Bw: min, max, aggreate percentage of total, mean, deviation
- CPU usage: user, system, context switches
+ cpuchunks=x Split burn cycles into pieces of x usecs.
Author
projects / fio.git / blobdiff