libio: fix bug in commit hook

[fio.git] / HOWTO

diff --git a/HOWTO b/HOWTO
index 24171e9b2f3ef7feeae341aa870155871726673c..ca095a322895be3065081db5bd600fb12609f3e7 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -262,6 +262,10 @@ filesize=siint     Individual file sizes. May be a range, in which case fio
                and limited to 'size' in total (if that is given). If not
                given, each created file is the same size.
 
                and limited to 'size' in total (if that is given). If not
                given, each created file is the same size.
 

+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.
+

 blocksize=siint
 bs=siint       The block size used for the io units. Defaults to 4k. Values
                can be given for both read and writes. If a single siint is
 blocksize=siint
 bs=siint       The block size used for the io units. Defaults to 4k. Values
                can be given for both read and writes. If a single siint is


@@ -281,6 +285,30 @@ bsrange=irange     Instead of giving a single block size, specify a range
                writes, however a second range can be given after a comma.
                See bs=.
 
                writes, however a second range can be given after a comma.
                See bs=.
 

+bssplit=str    Sometimes you want even finer grained control of the
+               block sizes issued, not just an even split between them.
+               This option allows you to weight various block sizes,
+               so that you are able to define a specific amount of
+               block sizes issued. The format for this option is:
+
+                       bssplit=blocksize/percentage:blocksize/percentage
+
+               for as many block sizes as needed. So if you want to define
+               a workload that has 50% 64k blocks, 10% 4k blocks, and
+               40% 32k blocks, you would write:
+
+                       bssplit=4k/10:64k/50:32k/40
+
+               Ordering does not matter. If the percentage is left blank,
+               fio will fill in the remaining values evenly. So a bssplit
+               option like this one:
+
+                       bssplit=4k/50:1k/:32k/
+
+               would have 50% 4k ios, and 25% 1k and 32k ios. The percentages
+               always add up to 100, if bssplit is given a range that adds
+               up to more, it will error out.
+

 blocksize_unaligned
 bs_unaligned   If this option is given, any byte size value within bsrange
                may be used as a block range. This typically wont work with
 blocksize_unaligned
 bs_unaligned   If this option is given, any byte size value within bsrange
                may be used as a block range. This typically wont work with


@@ -601,15 +629,6 @@ verify=str If writing to a file, fio can verify the file contents
                                (timestamp, block number etc.). The block
                                number is verified.
 
                                (timestamp, block number etc.). The block
                                number is verified.
 

-                       pattern Fill the IO buffers with a specific pattern,
-                               that we can use to verify. Depending on the
-                               width of the pattern, fio will fill 1/2/3/4
-                               bytes of the buffer at the time. The pattern
-                               cannot be larger than a 32-bit quantity. The
-                               given pattern is given as a postfix to this
-                               option, ala: verify=pattern:0x5a. It accepts
-                               both hex and dec values.
-

                        null    Only pretend to verify. Useful for testing
                                internals with ioengine=null, not for much
                                else.
                        null    Only pretend to verify. Useful for testing
                                internals with ioengine=null, not for much
                                else.


@@ -635,6 +654,14 @@ verify_interval=siint      Write the verification header at a finer granularity
                        size of header_interval. blocksize should divide this
                        evenly.
 
                        size of header_interval. blocksize should divide this
                        evenly.
 

+verify_pattern=int     If set, fio will fill the io buffers with this
+               pattern. Fio defaults to filling with totally random
+               bytes, but sometimes it's interesting to fill with a known
+               pattern for io verification purposes. Depending on the
+               width of the pattern, fio will fill 1/2/3/4 bytes of the
+               buffer at the time. The verify_pattern cannot be larger than
+               a 32-bit quantity.
+

 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
 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


@@ -861,7 +888,7 @@ Split up, the format is as follows:
                Submission latency: min, max, mean, deviation
                Completion latency: min, max, mean, deviation
                Bw: min, max, aggregate percentage of total, mean, deviation
                Submission latency: min, max, mean, deviation
                Completion latency: min, max, mean, deviation
                Bw: min, max, aggregate percentage of total, mean, deviation

-       CPU usage: user, system, context switches
+       CPU usage: user, system, context switches, major faults, minor faults

        IO depths: <=1, 2, 4, 8, 16, 32, >=64
        IO latencies: <=2, 4, 10, 20, 50, 100, 250, 500, 750, 1000, >=2000
        Text description
        IO depths: <=1, 2, 4, 8, 16, 32, >=64
        IO latencies: <=2, 4, 10, 20, 50, 100, 250, 500, 750, 1000, >=2000
        Text description