Restore BUSY_OK bypassing of bitmap

[fio.git] / HOWTO

diff --git a/HOWTO b/HOWTO
index ee9680a592b77120c9967b722448e49c54ea01f2..6391b82a9c79b31fe3e3b0f2fac2dd0b6caf57ae 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -716,6 +716,25 @@ rwmixwrite=int     How large a percentage of the mix should be writes. If both
                if fio is asked to limit reads or writes to a certain rate.
                If that is the case, then the distribution may be skewed.
 
+random_distribution=str:float  By default, fio will use a completely uniform
+               random distribution when asked to perform random IO. Sometimes
+               it is useful to skew the distribution in specific ways,
+               ensuring that some parts of the data is more hot than others.
+               fio includes the following distribution models:
+
+               random          Uniform random distribution
+               zipf            Zipf distribution
+               pareto          Pareto distribution
+
+               When using a zipf or pareto distribution, an input value
+               is also needed to define the access pattern. For zipf, this
+               is the zipf theta. For pareto, it's the pareto power. Fio
+               includes a test program, genzipf, that can be used visualize
+               what the given input values will yield in terms of hit rates.
+               If you wanted to use zipf with a theta of 1.2, you would use
+               random_distribution=zipf:1.2 as the option. If a non-uniform
+               model is used, fio will disable use of the random map.
+
 norandommap    Normally fio will cover every block of the file when doing
                random IO. If this option is given, fio will just get a
                new random offset without looking at past io history. This
@@ -780,6 +799,9 @@ rate_iops_min=int If fio doesn't meet this rate of IO, it will cause
                the job to exit. The same format as rate is used for read vs
                write seperation.
 
+max_latency=int        If set, fio will exit the job if it exceeds this maximum
+               latency. It will exit with an ETIME error.
+
 ratecycle=int  Average bandwidth for 'rate' and 'ratemin' over this number
                of milliseconds.
 
@@ -799,6 +821,24 @@ cpus_allowed=str Controls the same options as cpumask, but it allows a text
                allows a range of CPUs. Say you wanted a binding to CPUs
                1, 5, and 8-15, you would set cpus_allowed=1,5,8-15.
 
+numa_cpu_nodes=str Set this job running on spcified NUMA nodes' CPUs. The
+               arguments allow comma delimited list of cpu numbers,
+               A-B ranges, or 'all'. Note, to enable numa options support,
+               export the following environment variables,
+                       export EXTFLAGS+=" -DFIO_HAVE_LIBNUMA "
+                       export EXTLIBS+=" -lnuma "
+
+numa_mem_policy=str Set this job's memory policy and corresponding NUMA
+               nodes. Format of the argements:
+                       <mode>[:<nodelist>]
+               `mode' is one of the following memory policy:
+                       default, prefer, bind, interleave, local
+               For `default' and `local' memory policy, no node is
+               needed to be specified.
+               For `prefer', only one node is allowed.
+               For `bind' and `interleave', it allow comma delimited
+               list of numbers, A-B ranges, or 'all'.
+
 startdelay=time        Start this job the specified number of seconds after fio
                has started. Only useful if the job file contains several
                jobs, and you want to delay starting some jobs to a certain
@@ -1364,7 +1404,7 @@ Idle      Run
 ----    ---
 P              Thread setup, but not started.
 C              Thread created.
-I              Thread initialized, waiting.
+I              Thread initialized, waiting or generating necessary data.
        p       Thread running pre-reading file(s).
        R       Running, doing sequential reads.
        r       Running, doing random reads.