Add support for async IO verification offload

[fio.git] / HOWTO

diff --git a/HOWTO b/HOWTO
index 2be845c4add2f7ce6c7cebc4d95ca9ce9083622a..55662d34bae7d7cc2ed46a6b87d2a5fa971568ee 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -314,7 +314,8 @@ filesize=int        Individual file sizes. May be a range, in which case fio
 
 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
@@ -529,6 +530,9 @@ fsync=int   If writing to a file, issue a sync of the dirty data
                not sync the file. The exception is the sg io engine, which
                synchronizes the disk cache anyway.
 
+fsyncdata=int  Like fsync= but uses fdatasync() to only sync data and not
+               metadata blocks.
+
 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
@@ -700,6 +704,15 @@ mem=str            Fio can use various types of memory as the io unit buffer.
                location should point there. So if it's mounted in /huge,
                you would use mem=mmaphuge:/huge/somefile.
 
+iomem_align=int        This indiciates the memory alignment of the IO memory buffers.
+               Note that the given alignment is applied to the first IO unit
+               buffer, if using iodepth the alignment of the following buffers
+               are given by the bs used. In other words, if using a bs that is
+               a multiple of the page sized in the system, all buffers will
+               be aligned to this value. If using a bs that is not page
+               aligned, the alignment of subsequent IO memory buffers is the
+               sum of the iomem_align and bs used.
+
 hugepage-size=int
                Defines the size of a huge page. Must at least be equal
                to the system setting, see /proc/meminfo. Defaults to 4MiB.
@@ -728,7 +741,10 @@ create_on_open=bool        Don't pre-setup the files for IO, just create open()
 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.
+               and then drop the cache. This will only work for IO engines
+               that are seekable, since they allow you to read the same data
+               multiple times. Thus it will not work on eg network or splice
+               IO.
 
 unlink=bool    Unlink the job files when done. Not the default, as repeated
                runs of that job would then waste time recreating the file
@@ -811,6 +827,16 @@ 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
                failure.
+
+verify_async=int       Fio will normally verify IO inline from the submitting
+               thread. This option takes an integer describing how many
+               async offload threads to create for IO verification instead,
+               causing fio to offload the duty of verifying IO contents
+               to one or more separate threads.
+
+verify_async_cpus=str  Tell fio to set the given CPU affinity on the
+               async IO verification threads. See cpus_allowed for the
+               format used.
                
 stonewall      Wait for preceeding jobs in the job file to exit, before
                starting this one. Can be used to insert serialization
@@ -927,6 +953,14 @@ gtod_cpu=int       Sometimes it's cheaper to dedicate a single thread of
                for doing these time calls will be excluded from other
                uses. Fio will manually clear it from the CPU mask of other
                jobs.
+continue_on_error=bool Normally fio will exit the job on the first observed
+               failure. If this option is set, fio will continue the job when
+               there is a 'non-fatal error' (EIO or EILSEQ) until the runtime
+               is exceeded or the I/O size specified is completed. If this
+               option is used, there are two more stats that are appended,
+               the total error count and the first error. The error field
+               given in the stats is the first error that was hit during the
+               run.
 
 
 6.0 Interpreting the output