gfio: demo of how to inherit option values into edit window

[fio.git] / HOWTO

diff --git a/HOWTO b/HOWTO
index 0a3351c3f120d5b264f5cca5bcb93e796ed5137b..e4614ea8675a0c8b2f958ad8c2d6b04e12181939 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -488,6 +488,22 @@ scramble_buffers=bool      If refill_buffers is too costly and the target is
                block compression attempts, but it will stop naive dedupe of
                blocks. Default: true.
 
+buffer_compress_percentage=int If this is set, then fio will attempt to
+               provide IO buffer content (on WRITEs) that compress to
+               the specified level. Fio does this by providing a mix of
+               random data and zeroes. Note that this is per block size
+               unit, for file/disk wide compression level that matches
+               this setting, you'll also want to set refill_buffers.
+
+buffer_compress_chunk=int      See buffer_compress_percentage. This
+               setting allows fio to manage how big the ranges of random
+               data and zeroed data is. Without this set, fio will
+               provide buffer_compress_percentage of blocksize random
+               data, followed by the remaining zeroed. With this set
+               to some chunk size smaller than the block size, fio can
+               alternate random and zeroed data throughout the IO
+               buffer.
+
 nrfiles=int    Number of files to use for this job. Defaults to 1.
 
 openfiles=int  Number of files to keep open at the same time. Defaults to
@@ -636,6 +652,13 @@ offset=int Start io at the given offset in the file. The data before
                the given offset will not be touched. This effectively
                caps the file size at real_size - offset.
 
+offset_increment=int   If this is provided, then the real offset becomes
+               the offset + offset_increment * thread_number, where the
+               thread number is a counter that starts at 0 and is incremented
+               for each job. This option is useful if there are several jobs
+               which are intended to operate on a file in parallel in disjoint
+               segments, with even spacing between the starting points.
+
 fsync=int      If writing to a file, issue a sync of the dirty data
                for every number of blocks given. For example, if you give
                32 as a parameter, fio will sync the file for every 32