Async verify HOWTO/man update

[fio.git] / HOWTO

diff --git a/HOWTO b/HOWTO
index 536e370ba03f0c5f3c9d3d8fc03ddd559c0cc95b..5099c83c8fd7913773de58285ff323e2bdaec4d0 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -530,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
@@ -701,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.
@@ -729,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
@@ -812,6 +827,19 @@ 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. If using this offload
+               option, even sync IO engines can benefit from using an
+               iodepth setting higher than 1, as it allows them to have
+               IO in flight while verifies are running.
+
+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
@@ -928,6 +956,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