smalloc: cleanups and allow sfree(NULL)

[fio.git] / HOWTO

diff --git a/HOWTO b/HOWTO
index d5fb52cfb0f9f931db588c78d92e81a95480f2ca..32e7322cdc5155d3d6c2a1bf7875acbcd0cb7c2c 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -219,6 +219,25 @@ filename=str       Fio normally makes up a filename based on the job name,
 opendir=str    Tell fio to recursively add any file it can find in this
                directory and down the file system tree.
 
 opendir=str    Tell fio to recursively add any file it can find in this
                directory and down the file system tree.
 

+lockfile=str   Fio defaults to not doing any locking files before it does
+               IO to them. If a file or file descriptor is shared, fio
+               can serialize IO to that file to make the end result
+               consistent. This is usual for emulating real workloads that
+               share files. The lock modes are:
+
+                       none            No locking. The default.
+                       exclusive       Only one thread/process may do IO,
+                                       excluding all others.
+                       readwrite       Read-write locking on the file. Many
+                                       readers may access the file at the
+                                       same time, but writes get exclusive
+                                       access.
+
+               The option may be post-fixed with a lock batch number. If
+               set, then each thread/process may do that amount of IOs to
+               the file before giving up the lock. Since lock acqusition is
+               expensive, batching the lock/unlocks will speed up IO.
+

 readwrite=str
 rw=str         Type of io pattern. Accepted values are:
 
 readwrite=str
 rw=str         Type of io pattern. Accepted values are:
 


@@ -262,6 +281,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 +304,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


@@ -316,6 +363,8 @@ ioengine=str        Defines how the job issues io to the file. The following
 
                        psync   Basic pread(2) or pwrite(2) io.
 
 
                        psync   Basic pread(2) or pwrite(2) io.
 

+                       vsync   Basic readv(2) or writev(2) IO.
+

                        libaio  Linux native asynchronous io.
 
                        posixaio glibc posix asynchronous io.
                        libaio  Linux native asynchronous io.
 
                        posixaio glibc posix asynchronous io.


@@ -353,7 +402,10 @@ ioengine=str       Defines how the job issues io to the file. The following
                                cycles according to the cpuload= and
                                cpucycle= options. Setting cpuload=85
                                will cause that job to do nothing but burn
                                cycles according to the cpuload= and
                                cpucycle= options. Setting cpuload=85
                                will cause that job to do nothing but burn

-                               85% of the CPU.
+                               85% of the CPU. In case of SMP machines,
+                               use numjobs=<no_of_cpu> to get desired CPU
+                               usage, as the cpuload only loads a single
+                               CPU at the desired rate.

 
                        guasi   The GUASI IO engine is the Generic Userspace
                                Asyncronous Syscall Interface approach
 
                        guasi   The GUASI IO engine is the Generic Userspace
                                Asyncronous Syscall Interface approach


@@ -374,8 +426,9 @@ iodepth=int This defines how many io units to keep in flight against
                concurrency.
 
 iodepth_batch=int This defines how many pieces of IO to submit at once.
                concurrency.
 
 iodepth_batch=int This defines how many pieces of IO to submit at once.

-               It defaults to the same as iodepth, but can be set lower
-               if one so desires.
+               It defaults to 1 which means that we submit each IO
+               as soon as it is available, but can be raised to submit
+               bigger batches of IO at the time.

 
 iodepth_low=int        The low water mark indicating when to start filling
                the queue again. Defaults to the same as iodepth, meaning
 
 iodepth_low=int        The low water mark indicating when to start filling
                the queue again. Defaults to the same as iodepth, meaning


@@ -401,7 +454,11 @@ 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.
 
                not sync the file. The exception is the sg io engine, which
                synchronizes the disk cache anyway.
 

-overwrite=bool If writing to a file, setup the file first and do overwrites.
+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
+               and is large enough for the specified write phase, nothing
+               will be done.

 
 end_fsync=bool If true, fsync file contents when the job exits.
 
 
 end_fsync=bool If true, fsync file contents when the job exits.
 


@@ -409,10 +466,6 @@ fsync_on_close=bool        If true, fio will fsync() a dirty file on close.
                This differs from end_fsync in that it will happen on every
                file close, not just at the end of the job.
 
                This differs from end_fsync in that it will happen on every
                file close, not just at the end of the job.
 

-rwmixcycle=int Value in milliseconds describing how often to switch between
-               reads and writes for a mixed workload. The default is
-               500 msecs.
-

 rwmixread=int  How large a percentage of the mix should be reads.
 
 rwmixwrite=int How large a percentage of the mix should be writes. If both
 rwmixread=int  How large a percentage of the mix should be reads.
 
 rwmixwrite=int How large a percentage of the mix should be writes. If both


@@ -429,6 +482,12 @@ norandommap        Normally fio will cover every block of the file when doing
                fio doesn't track potential block rewrites which may alter
                the calculated checksum for that block.
 
                fio doesn't track potential block rewrites which may alter
                the calculated checksum for that block.
 

+softrandommap  See norandommap. If fio runs with the random block map enabled
+               and it fails to allocate the map, if this option is set it
+               will continue without a random block map. As coverage will
+               not be as complete as with random maps, this option is
+               disabled by default.
+

 nice=int       Run the job with the given nice value. See man nice(2).
 
 prio=int       Set the io priority value of this job. Linux limits us to
 nice=int       Run the job with the given nice value. See man nice(2).
 
 prio=int       Set the io priority value of this job. Linux limits us to


@@ -601,15 +660,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 +685,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