Provided by: stress-ng_0.05.23-1ubuntu2_amd64 bug

NAME

       stress-ng - a tool to load and stress a computer system

SYNOPSIS

       stress-ng [OPTION [ARG]] ...

DESCRIPTION

       stress-ng  will  stress  test  a  computer system in various selectable ways. It was designed to exercise
       various physical subsystems of a computer as well as the  various  operating  system  kernel  interfaces.
       stress-ng  also  has a wide range of CPU specific stress tests that exercise floating point, integer, bit
       manipulation and control flow.

       stress-ng was originally intended to make a machine work hard and trip hardware issues  such  as  thermal
       overruns  as  well  as  operating  system  bugs that only occur when a system is being thrashed hard. Use
       stress-ng with caution as some of the tests can make a system run hot on  poorly  designed  hardware  and
       also can cause excessive system thrashing which may be difficult to stop.

       stress-ng  can  also  measure  test  throughput  rates; this can be useful to observe performance changes
       across different operating system releases or types of hardware. However, it has never been  intended  to
       be used as a precise benchmark test suite, so do NOT use it in this manner.

       Running  stress-ng  with  root privileges will adjust out of memory settings on Linux systems to make the
       stressors unkillable in low memory situations, so use this judiciously.  With the appropriate  privilege,
       stress-ng  can  allow  the ionice class and ionice levels to be adjusted, again, this should be used with
       care.

       One can specify the number of processes to invoke per type of stress test; specifying a negative or  zero
       value will select the number of processors available as defined by sysconf(_SC_NPROCESSORS_CONF).

OPTIONS

       General stress-ng control options:

       --aggressive
              enables  more  file,  cache  and  memory  aggressive  options.  This may slow tests down, increase
              latencies and reduce the number of bogo ops as well as changing the balance of user time vs system
              time used depending on the type of stressor being used.

       -a N, --all N
              start N instances of each stressor. If N is less than zero, then the number of CPUs online is used
              for the number of instances.  If N is zero, then the number of CPUs in the system is used.

       -b N, --backoff N
              wait N microseconds between the start of each stress worker process. This allows one  to  ramp  up
              the stress tests over time.

       --class name
              specify  the class of stressors to run. Stressors are classified into one or more of the following
              classes: cpu, cpu-cache, device, io, interrupt, filesystem, memory, network, os,  pipe,  scheduler
              and  vm.   Some  stressors fall into just one class. For example the 'get' stressor is just in the
              'os' class. Other stressors fall into more than one class, for  example,  the  'lsearch'  stressor
              falls into the 'cpu', 'cpu-cache' and 'memory' classes as it exercises all these three.  Selecting
              a specific class will run all the stressors that fall into that  class  only  when  run  with  the
              --sequential option.

       -n, --dry-run
              parse options, but do not run stress tests. A no-op.

       -h, --help
              show help.

       --ignite-cpu
              alter  kernel  controls to try and maximize the CPU. This requires root privilege to alter various
              /sys interface controls.  Currently this only works for  Intel  P-State  enabled  x86  systems  on
              Linux.

       --ionice-class class
              specify ionice class (only on Linux). Can be idle (default), besteffort, be, realtime, rt.

       --ionice-level level
              specify  ionice  level (only on Linux). For idle, 0 is the only possible option. For besteffort or
              realtime values 0 (highest priority) to 7 (lowest priority). See ionice(1) for more details.

       -k, --keep-name
              by default, stress-ng will attempt to change the name of the stress processes according  to  their
              functionality;  this option disables this and keeps the process names to be the name of the parent
              process, that is, stress-ng.

       --log-brief
              by default stress-ng will report the name of the program, the message type and the process id as a
              prefix  to all output. The --log-brief option will output messages without these fields to produce
              a less verbose output.

       --log-file filename
              write messages to the specified log file.

       --maximize
              overrides the default stressor settings and instead sets these to the  maximum  settings  allowed.
              These defaults can always be overridden by the per stressor settings options if required.

       --metrics
              output  number of bogo operations in total performed by the stress processes.  Note that these are
              not a reliable metric of performance or throughput and have not  been  designed  to  be  used  for
              benchmarking  whatsoever.  The  metrics are just a useful way to observe how a system behaves when
              under various kinds of load.

              The following columns of information are output:

              Column Heading             Explanation
              bogo ops                   number of iterations of the stressor during the run. This is metric  of
                                         how much overall "work" has been achieved in bogo operations.
              real time (secs)           average  wall  clock duration (in seconds) of the stressor. This is the
                                         total wall clock time of all the instances of that particular  stressor
                                         divided by the number of these stressors being run.
              usr time (secs)            total  user time (in seconds) consumed running all the instances of the
                                         stressor.
              sys time (secs)            total system time (in seconds) consumed running all  the  instances  of
                                         the stressor.
              bogo ops/s (real time)     total bogo operations per second based on wall clock run time. The wall
                                         clock time reflects the apparent run time. The more processors one  has
                                         on  a  system  the more the work load can be distributed onto these and
                                         hence the wall clock time will  reduce  and  the  bogo  ops  rate  will
                                         increase.   This  is  essentially  the  "apparent" bogo ops rate of the
                                         system.
              bogo ops/s (usr+sys time)  total bogo operations per second based on cumulative  user  and  system
                                         time.   This  is  the  real  bogo  ops  rate  of the system taking into
                                         consideration the actual time execution time of the stressor across all
                                         the  processors.   Generally  this  will  decrease  as  one  adds  more
                                         concurrent stressors due to  contention  on  cache,  memory,  execution
                                         units, buses and I/O devices.

       --metrics-brief
              enable metrics and only output metrics that are non-zero.

       --minimize
              overrides  the  default  stressor settings and instead sets these to the minimum settings allowed.
              These defaults can always be overridden by the per stressor settings options if required.

       --no-advise
              from version 0.02.26 stress-ng automatically calls madvise(2) with random  advise  options  before
              each  mmap and munmap to stress the the vm subsystem a little harder. The --no-advise option turns
              this default off.

       --page-in
              touch allocated pages that are not in core, forcing them to be paged back in.  This  is  a  useful
              option  to  force  all  the  allocated  pages  to  be paged in when using the bigheap, mmap and vm
              stressors.  It will severely degrade performance when the memory in the system is  less  than  the
              allocated  buffer  sizes.   This  uses  mincore(2) to determine the pages that are not in core and
              hence need touching to page them back in.

       --pathological
              enable stressors that are known to hang systems.  Some stressors can quickly consume resources  in
              such  a  way  that  they  can  rapidly  hang  a  system before the kernel can OOM kill them. These
              stressors are not enabled by default, this option enables them, but you probably don't want to  do
              this. You have been warned.

       --perf measure  processor  and system activity using perf events. Linux only and caveat emptor, according
              to perf_event_open(2): "Always double-check your results!  Various  generalized  events  have  had
              wrong values."

       -q, --quiet
              do not show any output.

       -r N, --random N
              start N random stress workers. If N is 0, then the number of configured processors is used for N.

       --sched scheduler
              select the named scheduler (only on Linux). To see the list of available schedulers use: stress-ng
              --sched which

       --sched-prio prio
              select the scheduler priority level (only on Linux). If the scheduler does not support  this  then
              the default priority level of 0 is chosen.

       --sequential N
              sequentially run all the stressors one by one for a default of 60 seconds. The number of instances
              of each individual stressors to be started is N.  If N is less than zero, then the number of  CPUs
              online  is  used for the number of instances.  If N is zero, then the number of CPUs in the system
              is used.  Use the --timeout option to specify the duration to run each stressor.

       --syslog
              log output (except for verbose -v messages) to the syslog.

       --temp-path path
              specify a path for stress-ng temporary directories and temporary files; the default  path  is  the
              current  working  directory.   This  path must have read and write access for the stress-ng stress
              processes.

       -t N, --timeout N
              stop stress test after N seconds. One can also specify the units  of  time  in  seconds,  minutes,
              hours, days or years with the suffix s, m, h, d or y.

       --timer-slack N
              adjust  the  per  process  timer  slack  to N nanoseconds (Linux only). Increasing the timer slack
              allows the kernel to coalesce timer events by adding some fuzzinesss to timer expiration times and
              hence reduce wakeups.  Conversely, decreasing the timer slack will increase wakeups.  A value of 0
              for the timer-slack will set the system default of 50,000 nanoseconds.

       --times
              show the cumulative user and system times of all the child processes at the end of the stress run.
              The  percentage of utilisation of available CPU time is also calculated from the number of on-line
              CPUs in the system.

       --tz   collect temperatures from the available thermal zones on the machine (Linux only).   Some  devices
              may have one or more thermal zones, where as others may have none.

       -v, --verbose
              show all debug, warnings and normal information output.

       --verify
              verify  results when a test is run. This is not available on all tests. This will sanity check the
              computations or memory contents from a test run and report to stderr any unexpected failures.

       -V, --version
              show version.

       -x, --exclude list
              specify a list of one or more stressors to exclude (that is, do not run them).  This is useful  to
              exclude  specific  stressors  when  one  selects  many  stressors to run using the --class option,
              --sequential, --all and --random options. Example, run the cpu class  stressors  concurrently  and
              exclude the numa and search stressors:

              stress-ng --class cpu --all 1 -x numa,bsearch,hsearch,lsearch

       -Y, --yaml filename
              output gathered statistics to a YAML formatted file named 'filename'.

       Stressor specific options:

       --affinity N
              start  N  workers that rapidly change CPU affinity (only on Linux). Rapidly switching CPU affinity
              can contribute to poor cache behaviour.

       --affinity-ops N
              stop affinity workers after N bogo affinity operations (only on Linux).

       --affinity-rand
              switch CPU affinity randomly rather than the default of sequentially.

       --af-alg N
              start N workers that exercise the AF_ALG socket domain by hashing various  sized  random  messages
              using  SHA1,  SHA224,  SHA256,  SHA384,  SHA512,  MD4, MD5, RMD128, RMD160, RMD256, RMD320, WP256,
              WP384, WP512, TGR128, TGR160 and TGR192 hashes. (Linux only).

       --af-alg-ops N
              stop af-alg workers after N AF_ALG messages are hashed.

       --aio N
              start N workers that issue multiple small asynchronous I/O writes and reads on a relatively  small
              temporary  file  using the POSIX aio interface.  This will just hit the file system cache and soak
              up a lot of user and kernel time in issuing and handling I/O requests.  By  default,  each  worker
              process will handle 16 concurrent I/O requests.

       --aio-ops N
              stop POSIX asynchronous I/O workers after N bogo asynchronous I/O requests.

       --aio-requests N
              specify the number of POSIX asynchronous I/O requests each worker should issue, the default is 16;
              1 to 4096 are allowed.

       --aiol N
              start N workers that issue multiple 4K random asynchronous I/O writes using the Linux  aio  system
              calls  io_setup(2),  io_submit(2),  io_getevents(2)  and  io_destroy(2).   By default, each worker
              process will handle 16 concurrent I/O requests.

       --aiol-ops N
              stop Linux asynchronous I/O workers after N bogo asynchronous I/O requests.

       --aiol-requests N
              specify the number of Linux asynchronous I/O requests each worker should issue, the default is 16;
              1 to 4096 are allowed.

       --apparmor N
              start  N  workers  that exercise various parts of the AppArmor interface. Currently one needs root
              permission to run this particular test. This test is only available on Linux systems with AppArmor
              support.

       --apparmor-ops
              stop the AppArmor workers after N bogo operations.

       -B N, --bigheap N
              start N workers that grow their heaps by reallocating memory. If the out of memory killer (OOM) on
              Linux kills the worker or the allocation fails then the allocating process starts all over  again.
              Note that the OOM adjustment for the worker is set so that the OOM killer will treat these workers
              as the first candidate processes to kill.

       --bigheap-ops N
              stop the big heap workers after N bogo allocation operations are completed.

       --bigheap-growth N
              specify amount of memory to grow heap by per iteration. Size can be from 4K to  64MB.  Default  is
              64K.

       --bind-mount N
              start  N  workers  that  repeatedly  bind  mount  / to / inside a user namespace. This can consume
              resources rapidly, forcing out of memory situations. Do not use this stressor unless you  want  to
              risk hanging your machine.

       --bind-mount-ops N
              stop after N bind mount bogo operations.

       --brk N
              start N workers that grow the data segment by one page at a time using multiple brk(2) calls. Each
              successfully allocated new page is touched to ensure it is resident  in  memory.   If  an  out  of
              memory  condition  occurs then the test will reset the data segment to the point before it started
              and repeat the data segment resizing over again.  The process adjusts the out of memory setting so
              that  it  may be killed by the out of memory (OOM) killer before other processes.  If it is killed
              by the OOM killer then it will be automatically re-started by a monitoring parent process.

       --brk-ops N
              stop the brk workers after N bogo brk operations.

       --brk-notouch
              do not touch each newly allocated data segment page. This disables the default  of  touching  each
              newly  allocated  page  and  hence  avoids  the kernel from necessarily backing the page with real
              physical memory.

       --bsearch N
              start N workers that binary search a sorted array of 32 bit integers using bsearch(3). By default,
              there  are  65536  elements  in  the  array.  This is a useful method to exercise random access of
              memory and processor cache.

       --bsearch-ops N
              stop the bsearch worker after N bogo bsearch operations are completed.

       --bsearch-size N
              specify the size (number of 32 bit integers) in the array to bsearch. Size can be from 1K to 4M.

       -C N, --cache N
              start N workers that perform random wide spread memory read and writes to thrash  the  CPU  cache.
              The code does not intelligently determine the CPU cache configuration and so it may be sub-optimal
              in producing hit-miss read/write activity for some processors.

       --cache-fence
              force write serialization on each store  operation  (x86  only).  This  is  a  no-op  for  non-x86
              architectures.

       --cache-flush
              force flush cache on each store operation (x86 only). This is a no-op for non-x86 architectures.

       --cache-level N
              specify level of cache to exercise (1=L1 cache, 2=L2 cache, 3=L3/LLC cache (the default)).  If the
              cache hierarchy cannot be determined, built-in defaults will apply.

       --cache-no-affinity
              do not change processor affinity when --cache is in effect.

       --cache-ops N
              stop cache thrash workers after N bogo cache thrash operations.

       --cache-prefetch
              force read prefetch on next read address on architectures that support prefetching.

       --cache-ways N
              specify the number of cache ways to exercise. This allows a subset of the overall cache size to be
              exercised.

       --cap N
              start N workers that read per process capabililties via calls to capget(2) (Linux only).

       --cap-ops N
              stop after N cap bogo operations.

       --chdir N
              start N workers that change directory between 8192 directories using chdir(2).

       --chdir-ops N
              stop after N chdir bogo operations.

       --chmod N
              start  N  workers  that change the file mode bits via chmod(2) and fchmod(2) on the same file. The
              greater the value for N then the more contention on the  single  file.   The  stressor  will  work
              through all the combination of mode bits.

       --chmod-ops N
              stop after N chmod bogo operations.

       --clock N
              start  N  workers exercising clocks and POSIX timers. For all known clock types this will exercise
              clock_getres(2), clock_gettime(2) and clock_nanosleep(2).  For all known timers it will  create  a
              50000ns  timer  and  busy  poll  this until it expires.  This stressor will cause frequent context
              switching.

       --clock-ops N
              stop clock stress workers after N bogo operations.

       --clone N
              start N workers that create clones (via the clone(2) system call). This will rapidly try to create
              a  default  of  8192 clones that immediately die and wait in a zombie state until they are reaped.
              Once the maximum number of clones is reached (or clone fails because one has reached  the  maximum
              allowed) the oldest clone thread is reaped and a new clone is then created in a first-in first-out
              manner, and then repeated.  A random clone flag is selected for each  clone  to  try  to  exercise
              different clone operarions.  The clone stressor is a Linux only option.

       --clone-ops N
              stop clone stress workers after N bogo clone operations.

       --clone-max N
              try to create as many as N clone threads. This may not be reached if the system limit is less than
              N.

       --context N
              start N workers that run three threads that use swapcontext(3) to implement  the  thread-to-thread
              context  switching.  This  exercises  rapid  process context saving and restoring and is bandwidth
              limited by register and memory save and restore rates.

       --context-ops N
              stop N context workers after N bogo context switches.  In this stressor, 1 bogo op  is  equivalent
              to 1000 swapcontext calls.

       --copy-file N
              start  N  stressors that copy a file using the Linux copy_file_range(2) system call. 2MB chunks of
              data are copyied from random locations from one file to random locations to  a  destination  file.
              By  default,  the  files  are  256  MB  in  size.  Data  is  sync'd  to  the filesystem after each
              copy_file_range(2) call.

       --copy-file-ops N
              stop after N copy_file_range() calls.

       --copy-file-bytes N
              copy file size, the default is 256 MB. One can specify the size in units of Bytes, KBytes,  MBytes
              and GBytes using the suffix b, k, m or g.

       -c N, --cpu N
              start  N  workers  exercising the CPU by sequentially working through all the different CPU stress
              methods. Instead of exercising all the CPU stress methods, one can specify a specific  CPU  stress
              method with the --cpu-method option.

       --cpu-ops N
              stop cpu stress workers after N bogo operations.

       -l P, --cpu-load P
              load CPU with P percent loading for the CPU stress workers. 0 is effectively a sleep (no load) and
              100 is full loading.  The loading loop is broken into compute time (load%) and sleep time (100%  -
              load%).  Accuracy  depends  on  the  overall  load  of the processor and the responsiveness of the
              scheduler, so the actual load may be different from the desired load.  Note  that  the  number  of
              bogo  CPU operations may not be linearly scaled with the load as some systems employ CPU frequency
              scaling and so heavier loads produce an increased CPU frequency and greater CPU bogo operations.

       --cpu-load-slice S
              note - this option is only useful when --cpu-load is less than 100%. The CPU load is  broken  into
              multiple  busy  and  idle cycles. Use this option to specify the duration of a busy time slice.  A
              negative value for S specifies the number of iterations to run before idling  the  CPU  (e.g.  -30
              invokes  30  iterations  of a CPU stress loop).  A zero value selects a random busy time between 0
              and 0.5 seconds.  A positive value for S specifies the number of milliseconds to run before idling
              the  CPU  (e.g.  100  keeps the CPU busy for 0.1 seconds).  Specifying small values for S lends to
              small time slices and smoother scheduling.  Setting --cpu-load  as  a  relatively  low  value  and
              --cpu-load-slice  to  be  large  will cycle the CPU between long idle and busy cycles and exercise
              different CPU frequencies.  The thermal range of the CPU  is  also  cycled,  so  this  is  a  good
              mechanism  to  exercise  the  scheduler,  frequency  scaling  and  passive/active  thermal cooling
              mechanisms.

       --cpu-method method
              specify a cpu stress method. By default,  all  the  stress  methods  are  exercised  sequentially,
              however  one can specify just one method to be used if required.  Available cpu stress methods are
              described as follows:

              Method           Description
              all              iterate over all the below cpu stress methods
              ackermann        Ackermann function: compute A(3, 10), where:
                                A(m, n) = n + 1 if m = 0;
                                A(m - 1, 1) if m > 0 and n = 0;
                                A(m - 1, A(m, n - 1)) if m > 0 and n > 0
              bitops           various bit operations from bithack, namely:  reverse  bits,  parity  check,  bit
                               count, round to nearest power of 2
              callfunc         recursively call 8 argument C function to a depth of 1024 calls and unwind
              cfloat           1000 iterations of a mix of floating point complex operations
              cdouble          1000 iterations of a mix of double floating point complex operations
              clongdouble      1000 iterations of a mix of long double floating point complex operations
              correlate        perform a 16384 × 1024 correlation of random doubles
              crc16            compute 1024 rounds of CCITT CRC16 on random data

              decimal32        1000 iterations of a mix of 32 bit decimal floating point operations (GCC only)
              decimal64        1000 iterations of a mix of 64 bit decimal floating point operations (GCC only)
              decimal128       1000 iterations of a mix of 128 bit decimal floating point operations (GCC only)
              dither           Floyd–Steinberg  dithering of a 1024 × 768 random image from 8 bits down to 1 bit
                               of depth.
              djb2a            128 rounds of hash DJB2a (Dan Bernstein hash using the xor variant) on 128  to  1
                               bytes of random strings
              double           1000 iterations of a mix of double precision floating point operations
              euler            compute e using n = (1 + (1 ÷ n)) ↑ n
              explog           iterate on n = exp(log(n) ÷ 1.00002)
              fibonacci        compute Fibonacci sequence of 0, 1, 1, 2, 5, 8...
              fft              4096 sample Fast Fourier Transform
              float            1000 iterations of a mix of floating point operations
              fnv1a            128  rounds  of  hash  FNV-1a  (Fowler–Noll–Vo  hash  using the xor then multiply
                               variant) on 128 to 1 bytes of random strings
              gamma            calculate the Euler-Mascheroni constant γ using the limiting  difference  between
                               the  harmonic  series  (1  +  1/2  +  1/3  + 1/4 + 1/5 ... + 1/n) and the natural
                               logarithm ln(n), for n = 80000.
              gcd              compute GCD of integers
              gray             calculate binary to gray code and gray code back to binary for integers from 0 to
                               65535
              hamming          compute  Hamming H(8,4) codes on 262144 lots of 4 bit data. This turns 4 bit data
                               into 8 bit Hamming code containing 4 parity bits. For data  bits  d1..d4,  parity
                               bits are computed as:
                                 p1 = d2 + d3 + d4
                                 p2 = d1 + d3 + d4
                                 p3 = d1 + d2 + d4
                                 p4 = d1 + d2 + d3
              hanoi            solve a 21 disc Towers of Hanoi stack using the recursive solution
              hyperbolic       compute sinh(θ) × cosh(θ) + sinh(2θ) + cosh(3θ) for float, double and long double
                               hyperbolic sine and cosine functions where θ = 0 to 2π in 1500 steps
              idct             8 × 8 IDCT (Inverse Discrete Cosine Transform)
              int8             1000 iterations of a mix of 8 bit integer operations
              int16            1000 iterations of a mix of 16 bit integer operations
              int32            1000 iterations of a mix of 32 bit integer operations
              int64            1000 iterations of a mix of 64 bit integer operations
              int128           1000 iterations of a mix of 128 bit integer operations (GCC only)
              int32float       1000 iterations of a mix of 32 bit integer and floating point operations
              int32double      1000 iterations of a mix of 32 bit integer and double  precision  floating  point
                               operations
              int32longdouble  1000  iterations  of  a  mix of 32 bit integer and long double precision floating
                               point operations
              int64float       1000 iterations of a mix of 64 bit integer and floating point operations
              int64double      1000 iterations of a mix of 64 bit integer and double  precision  floating  point
                               operations
              int64longdouble  1000  iterations  of  a  mix of 64 bit integer and long double precision floating
                               point operations
              int128float      1000 iterations of a mix of 128 bit integer and floating  point  operations  (GCC
                               only)
              int128double     1000  iterations  of a mix of 128 bit integer and double precision floating point
                               operations (GCC only)
              int128longdouble 1000 iterations of a mix of 128 bit integer and long  double  precision  floating
                               point operations (GCC only)
              int128decimal32  1000  iterations  of  a  mix of 128 bit integer and 32 bit decimal floating point
                               operations (GCC only)
              int128decimal64  1000 iterations of a mix of 128 bit integer and 64  bit  decimal  floating  point
                               operations (GCC only)
              int128decimal128 1000  iterations  of  a mix of 128 bit integer and 128 bit decimal floating point
                               operations (GCC only)
              jenkin           Jenkin's integer hash on 128 rounds of 128..1 bytes of random data
              jmp              Simple unoptimised compare >, <, == and jmp branching
              ln2              compute ln(2) based on series:
                                1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 ...
              longdouble       1000 iterations of a mix of long double precision floating point operations
              loop             simple empty loop

              matrixprod       matrix product of two 128 × 128 matrices of double floats. Testing on 64 bit  x86
                               hardware  shows  that  this  is provides a good mix of memory, cache and floating
                               point operations and is probably the best CPU method to use to  make  a  CPU  run
                               hot.
              nsqrt            compute sqrt() of long doubles using Newton-Raphson
              omega            compute  the omega constant defined by Ωe↑Ω = 1 using efficient iteration of Ωn+1
                               = (1 + Ωn) / (1 + e↑Ωn)
              parity           compute parity using various methods from  the  Standford  Bit  Twiddling  Hacks.
                               Methods  employed  are:  the naïve way, the naïve way with the Brian Kernigan bit
                               counting optimisation, the multiply way, the parallel way, and the  lookup  table
                               ways (2 variations).
              phi              compute the Golden Ratio ϕ using series
              pi               compute π using the Srinivasa Ramanujan fast convergence algorithm
              pjw              128 rounds of hash pjw function on 128 to 1 bytes of random strings
              prime            find  all  the  primes  in the range  1..1000000 using a slightly optimised brute
                               force naïve trial division search
              psi              compute ψ (the reciprocal Fibonacci constant) using the sum of the reciprocals of
                               the Fibonacci numbers
              queens           compute all the solutions of the classic 8 queens problem for board sizes 1..12
              rand             16384 iterations of rand(), where rand is the MWC pseudo random number generator.
                               The MWC random function concatenates two 16 bit multiply-with-carry generators:
                                x(n) = 36969 × x(n - 1) + carry,
                                y(n) = 18000 × y(n - 1) + carry mod 2 ↑ 16

                               and has period of around 2 ↑ 60
              rand48           16384 iterations of drand48(3) and lrand48(3)
              rgb              convert RGB to YUV and back to RGB (CCIR 601)
              sdbm             128 rounds of hash sdbm (as used in the SDBM database and GNU awk) on  128  to  1
                               bytes of random strings
              sieve            find the primes in the range 1..10000000 using the sieve of Eratosthenes
              sqrt             compute sqrt(rand()), where rand is the MWC pseudo random number generator
              trig             compute  sin(θ)  ×  cos(θ)  + sin(2θ) + cos(3θ) for float, double and long double
                               sine and cosine functions where θ = 0 to 2π in 1500 steps
              union            perform integer arithmetic on a mix of bit fields in a C union.   This  exercises
                               how well the compiler and CPU can perform integer bit field loads and stores.
              zeta             compute the Riemann Zeta function ζ(s) for s = 2.0..10.0

              Note that some of these methods try to exercise the CPU with computations found in some real world
              use cases. However, the code has not been optimised on a per-architecture basis, so may be a  sub-
              optimal  compared  to hand-optimised code used in some applications.  They do try to represent the
              typical instruction mixes found in these use cases.

       --cpu-online N
              start N workers that put randomly selected CPUs offline  and  online.  This  Linux  only  stressor
              requires root privilege to perform this action.

       --cpu-online-ops N
              stop after offline/online operations.

       --crypt N
              start  N  workers  that  encrypt  a  16 character random password using crypt(3).  The password is
              encrypted using MD5, SHA-256 and SHA-512 encryption methods.

       --crypt-ops N
              stop after N bogo encryption operations.

       --daemon N
              start N workers that each create a daemon that dies immediately after creating another daemon  and
              so  on.  This  effectively  works through the process table with short lived processes that do not
              have a parent and are waited for by init.  This puts pressure on init to do rapid  child  reaping.
              The  daemon  processes  perform  the usual mix of calls to turn into typical UNIX daemons, so this
              artificially mimics very heavy daemon system stress.

       --daemon-ops N
              stop daemon workers after N daemons have been created.

       -D N, --dentry N
              start N workers that create and remove directory entries.  This should  create  file  system  meta
              data  activity. The directory entry names are suffixed by a gray-code encoded number to try to mix
              up the hashing of the namespace.

       --dentry-ops N
              stop denty thrash workers after N bogo dentry operations.

       --dentry-order [ forward | reverse | stride | random ]
              specify unlink order of dentries, can be one of forward, reverse, stride or random.   By  default,
              dentries  are  unlinked  in  random order.  The forward order will unlink them from first to last,
              reverse order will unlink them from last to first, stride  order  will  unlink  them  by  stepping
              around  order  in  a  quasi-random  pattern  and random order will randomly select one of forward,
              reverse or stride orders.

       --dentries N
              create N dentries per dentry thrashing loop, default is 2048.

       --dir N
              start N workers that create and remove directories using mkdir and rmdir.

       --dir-ops N
              stop directory thrash workers after N bogo directory operations.

       --dup N
              start N workers that perform dup(2) and then close(2) operations on /dev/zero.  The maximum  opens
              at  one  time  is  system  defined,  so  the  test will run up to this maximum, or 65536 open file
              descriptors, which ever comes first.

       --dup-ops N
              stop the dup stress workers after N bogo open operations.

       --epoll N
              start N workers that perform various related socket stress activity using epoll_wait(2) to monitor
              and  handle  new  connections.  This  involves  client/server  processes performing rapid connect,
              send/receives and disconnects on the local host.  Using epoll allows a large number of connections
              to  be efficiently handled, however, this can lead to the connection table filling up and blocking
              further socket connections, hence impacting on the  epoll  bogo  op  stats.   For  ipv4  and  ipv6
              domains, multiple servers are spawned on multiple ports. The epoll stressor is for Linux only.

       --epoll-domain D
              specify  the  domain  to  use,  the default is unix (aka local). Currently ipv4, ipv6 and unix are
              supported.

       --epoll-port P
              start at socket port P. For N epoll worker processes, ports P to (P * 4) - 1 are  used  for  ipv4,
              ipv6 domains and ports P to P - 1 are used for the unix domain.

       --epoll-ops N
              stop epoll workers after N bogo operations.

       --eventfd N
              start  N  parent and child worker processes that read and write 8 byte event messages between them
              via the eventfd mechanism (Linux only).

       --eventfd-ops N
              stop eventfd workers after N bogo operations.

       --exec N
              start N workers continually forking children that exec stress-ng and then exit almost immediately.

       --exec-ops N
              stop exec stress workers after N bogo operations.

       --exec-max P
              create P child processes that exec stress-ng and then wait for them to  exit  per  iteration.  The
              default  is  just 1; higher values will create many temporary zombie processes that are waiting to
              be reaped. One can potentially fill up the process table using  high  values  for  --exec-max  and
              --exec.

       -F N, --fallocate N
              start   N  workers  continually  fallocating  (preallocating  file  space)  and  ftuncating  (file
              truncating) temporary files.  If the file is larger than the free space, fallocate will produce an
              ENOSPC error which is ignored by this stressor.

       --fallocate-bytes N
              allocated  file  size,  the  default  is 1 GB. One can specify the size in units of Bytes, KBytes,
              MBytes and GBytes using the suffix b, k, m or g.

       --fallocate-ops N
              stop fallocate stress workers after N bogo fallocate operations.

       --fault N
              start N workers that generates minor and major page faults.

       --fault-ops N
              stop the page fault workers after N bogo page fault operations.

       --fcntl N
              start N workers that perform fcntl(2) calls with various commands.   The  exercised  commands  (if
              available)  are: F_DUPFD, F_DUPFD_CLOEXEC, F_GETFD, F_SETFD, F_GETFL, F_SETFL, F_GETOWN, F_SETOWN,
              F_GETOWN_EX, F_SETOWN_EX, F_GETSIG and F_SETSIG.

       --fcntl-ops N
              stop the fcntl workers after N bogo fcntl operations.

       --fiemap N
              start N workers that each create a file with many  randomly  changing  extents  and  has  4  child
              processes per worker that gather the extent information using the FS_IOC_FIEMAP ioctl(2).

       --fiemap-ops N
              stop after N fiemap bogo operations.

       --fiemap-size N
              specify  the  size  of  the  fiemap'd  file in bytes.  One can specify the size in units of Bytes,
              KBytes, MBytes and GBytes using the suffix b, k, m or g.  Larger files will contain more  extents,
              causing more stress when gathering extent information.

       --fifo N
              start N workers that exercise a named pipe by transmitting 64 bit integers.

       --fifo-ops N
              stop fifo workers after N bogo pipe write operations.

       --fifo-readers N
              for  each  worker,  create  N  fifo  reader workers that read the named pipe using simple blocking
              reads.

       --filename N
              start N workers that exercise file creation using various length filenames containing a  range  of
              allower  filename  characters.   This  will  try  to  see if it can exceed the file system allowed
              filename length was well as test various filename lengths between 1 and the maximum allowed by the
              file system.

       --filename-ops N
              stop filename workers after N bogo filename tests.

       --filename-opts opt
              use characters in the filename based on option 'opt'. Valid options are:

              Option           Description
              probe            default option, probe the file system for valid allowed characters in a file name
                               and use these
              posix            use characters as specifed  by  The  Open  Group  Base  Specifications  Issue  7,
                               POSIX.1-2008, 3.278 Portable Filename Character Set
              ext              use  characters  allowed  by  the ext2, ext3, ext4 file systems, namely any 8 bit
                               character apart from NUL and /

       --flock N
              start N workers locking on a single file.

       --flock-ops N
              stop flock stress workers after N bogo flock operations.

       -f N, --fork N
              start N workers continually forking children that immediately exit.

       --fork-ops N
              stop fork stress workers after N bogo operations.

       --fork-max P
              create P child processes and then wait for them to exit per iteration.  The  default  is  just  1;
              higher  values  will create many temporary zombie processes that are waiting to be reaped. One can
              potentially fill up the the process table using high values for --fork-max and --fork.

       --fp-error N
              start N workers that generate floating point exceptions. Computations are performed to  force  and
              check for the FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW and FE_UNDERFLOW exceptions.  EDOM
              and ERANGE errors are also checked.

       --fp-error-ops N
              stop after N bogo floating point exceptions.

       --fstat N
              start N workers fstat'ing files in a directory (default is /dev).

       --fstat-ops N
              stop fstat stress workers after N bogo fstat operations.

       --fstat-dir directory
              specify the directory to fstat to override the default of /dev.  All the files  in  the  directory
              will be fstat'd repeatedly.

       --futex N
              start  N  workers  that  rapidly  exercise the futex system call. Each worker has two processes, a
              futex waiter and a futex waker. The waiter waits with a very small timeout to stress  the  timeout
              and rapid polled futex waiting. This is a Linux specific stress option.

       --futex-ops N
              stop futex workers after N bogo successful futex wait operations.

       --get N
              start N workers that call all the get*(2) system calls.

       --get-ops N
              stop get workers after N bogo get operations.

       --getdent N
              start N workers that recursively read directories /proc, /dev/, /tmp, /sys and /run using getdents
              and getdents64 (Linux only).

       --getdent-ops N
              stop getdent workers after N bogo getdent bogo operations.

       --getrandom N
              start N workers that get 8192 random bytes from  the  /dev/urandom  pool  using  the  getrandom(2)
              system call (Linux only).

       --getrandom-ops N
              stop getrandom workers after N bogo get operations.

       --handle N
              start  N  workers  that  exercise  the name_to_handle_at(2) and open_by_handle_at(2) system calls.
              (Linux only).

       --handle-ops N
              stop after N handle bogo operations.

       -d N, --hdd N
              start N workers continually writing, reading and removing temporary files.

       --hdd-bytes N
              write N bytes for each hdd process, the default is 1 GB. One can specify  the  size  in  units  of
              Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --hdd-opts list
              specify various stress test options as a comma separated list. Options are as follows:

              Option           Description
              direct           try  to minimize cache effects of the I/O. File I/O writes are performed directly
                               from user space buffers and synchronous transfer is also attempted.  To guarantee
                               synchronous I/O, also use the sync option.
              dsync            ensure  output  has been transferred to underlying hardware and file metadata has
                               been updated (using the O_DSYNC open flag). This is equivalent to  each  write(2)
                               being followed by a call to fdatasync(2). See also the fdatasync option.
              fadv-dontneed    advise kernel to expect the data will not be accessed in the near future.
              fadv-noreuse     advise kernel to expect the data to be accessed only once.
              fadv-normal      advise  kernel  there  are  no  explicit access pattern for the data. This is the
                               default advice assumption.
              fadv-rnd         advise kernel to expect random access patterns for the data.
              fadv-seq         advise kernel to expect sequential access patterns for the data.
              fadv-willneed    advise kernel to expect the data to be accessed in the near future.
              fsync            flush all modified in-core data after each write to the output  device  using  an
                               explicit fsync(2) call.
              fdatasync        similar  to  fsync,  but  do  not  flush the modified metadata unless metadata is
                               required for later data reads to be handled  correctly.  This  uses  an  explicit
                               fdatasync(2) call.
              iovec            use  readv/writev  multiple  buffer  I/Os  rather  than  read/write. Instead of 1
                               read/write operation, the buffer is broken into an iovec of 16 buffers.
              noatime          do not update the file last access timestamp, this can reduce metadata writes.
              sync             ensure output has been transferred to underlying hardware (using the O_SYNC  open
                               flag).  This  is  equivalent  to  a  each  write(2)  being  followed by a call to
                               fsync(2). See also the fsync option.
              rd-rnd           read data randomly. By default, written data is  not  read  back,  however,  this
                               option will force it to be read back randomly.
              rd-seq           read  data sequentially. By default, written data is not read back, however, this
                               option will force it to be read back sequentially.
              syncfs           write all buffered modifications of file metadata and data on the filesystem that
                               contains the hdd worker files.
              utimes           force update of file timestamp which may increase metadata writes.
              wr-rnd           write data randomly. The wr-seq option cannot be used at the same time.
              wr-seq           write data sequentially. This is the default if no write modes are specified.

       Note  that  some  of  these  options are mutually exclusive, for example, there can be only one method of
       writing or reading.  Also, fadvise flags may be mutually exclusive, for example fadv-willneed  cannot  be
       used with fadv-dontneed.

       --hdd-ops N
              stop hdd stress workers after N bogo operations.

       --hdd-write-size N
              specify size of each write in bytes. Size can be from 1 byte to 4MB.

       --heapsort N
              start N workers that sort 32 bit integers using the BSD heapsort.

       --heapsort-ops N
              stop heapsort stress workers after N bogo heapsorts.

       --heapsort-size N
              specify number of 32 bit integers to sort, default is 262144 (256 × 1024).

       --hsearch N
              start  N  workers  that  search a 80% full hash table using hsearch(3). By default, there are 8192
              elements inserted into the hash table.  This is a useful method to exercise access of  memory  and
              processor cache.

       --hsearch-ops N
              stop the hsearch workers after N bogo hsearch operations are completed.

       --hsearch-size N
              specify the number of hash entries to be inserted into the hash table. Size can be from 1K to 4M.

       --icache N
              start  N  workers that stress the instruction cache by forcing instruction cache reloads.  This is
              achieved by modifying an instruction cache line,  causing the processor to reload it when we  call
              a function in inside it. Currently only verified and enabled for Intel x86 CPUs.

       --icache-ops N
              stop the icache workers after N bogo icache operations are completed.

       --inotify N
              start  N  workers  performing  file  system  activities such as making/deleting files/directories,
              moving files, etc. to stress exercise the various inotify events (Linux only).

       --inotify-ops N
              stop inotify stress workers after N inotify bogo operations.

       -i N, --io N
              start N workers continuously calling sync(2) to commit buffer cache to disk.  This can be used  in
              conjunction with the --hdd options.

       --io-ops N
              stop io stress workers after N bogo operations.

       --itimer N
              start  N workers that exercise the system interval timers. This sets up an ITIMER_PROF itimer that
              generates a SIGPROF signal.  The default frequency for the itimer is 1  MHz,  however,  the  Linux
              kernel  will  set  this to be no more that the jiffy setting, hence high frequency SIGPROF signals
              are not normally possible.  A busy loop spins on getitimer(2)  calls  to  consume  CPU  and  hence
              decrement the itimer based on amount of time spent in CPU and system time.

       --itimer-ops N
              stop itimer stress workers after N bogo itimer SIGPROF signals.

       --itimer-freq F
              run  itimer  at F Hz; range from 1 to 1000000 Hz. Normally the highest frequency is limited by the
              number of jiffy ticks per second, so running above 1000 Hz is difficult to attain in practice.

       --kcmp N
              start N workers that use kcmp(2) to compare parent and child processes to determine if they  share
              kernel resources (Linux only).

       --kcmp-ops N
              stop kcmp workers after N bogo kcmp operations.

       --key N
              start  N  workers that create and manipulate keys using add_key(2) and ketctl(2). As many keys are
              created as the per user limit allows and then the following keyctl commands are exercised on  each
              key:   KEYCTL_SET_TIMEOUT,   KEYCTL_DESCRIBE,   KEYCTL_UPDATE,   KEYCTL_READ,   KEYCTL_CLEAR   and
              KEYCTL_INVALIDATE.

       --key-ops N
              stop key workers after N bogo key operations.

       --kill N
              start N workers sending SIGUSR1 kill signals to a SIG_IGN signal handler. Most of the process time
              will end up in kernel space.

       --kill-ops N
              stop kill workers after N bogo kill operations.

       --klog N
              start N workers exercising the kernel syslog(2) system call.  This will attempt to read the kernel
              log with various sized read buffers. Linux only.

       --klog-ops N
              stop klog workers after N syslog operations.

       --lease N
              start N workers locking, unlocking and breaking leases via the fcntl(2) F_SETLEASE operation.  The
              parent  processes  continually lock and unlock a lease on a file while a user selectable number of
              child processes open  the  file  with  a  non-blocking  open  to  generate  SIGIO  lease  breaking
              notifications  to  the parent.  This stressor is only available if F_SETLEASE, F_WRLCK and F_UNLCK
              support is provided by fcntl(2).

       --lease-ops N
              stop lease workers after N bogo operations.

       --lease-breakers N
              start N lease breaker child processes per lease worker.  Normally one child  is  plenty  to  force
              many  SIGIO  lease breaking notification signals to the parent, however, this option allows one to
              specify more child processes if required.

       --link N
              start N workers creating and removing hardlinks.

       --link-ops N
              stop link stress workers after N bogo operations.

       --lockbus N
              start N workers that rapidly lock and increment 64 bytes of randomly chosen  memory  from  a  16MB
              mmap'd region (Intel x86 CPUs only).  This will cause cacheline misses and stalling of CPUs.

       --lockbus-ops N
              stop lockbus workers after N bogo operations.

       --lockf N
              start  N  workers that randomly lock and unlock regions of a file using the POSIX lockf(3) locking
              mechanism. Each worker creates a 64K file and attempts to hold a maximum of 1024 concurrent  locks
              with  a  child  process that also tries to hold 1024 concurrent locks. Old locks are unlocked in a
              first-in, first-out basis.

       --lockf-ops N
              stop lockf workers after N bogo lockf operations.

       --lockf-nonblock
              instead of using blocking F_LOCK lockf(3) commands, use non-blocking F_TLOCK commands  and  re-try
              if  the lock failed.  This creates extra system call overhead and CPU utilisation as the number of
              lockf workers increases and should increase locking contention.

       --longjmp N
              start N workers that exercise setjmp(3)/longjmp(3) by rapid looping on longjmp calls.

       --longjmp-ops N
              stop longjmp stress workers after N bogo longjmp operations (1 bogo op is 1000 longjmp calls).

       --lsearch N
              start N workers that linear search a unsorted array  of  32  bit  integers  using  lsearch(3).  By
              default,  there  are  8192  elements in the array.  This is a useful method to exercise sequential
              access of memory and processor cache.

       --lsearch-ops N
              stop the lsearch workers after N bogo lsearch operations are completed.

       --lsearch-size N
              specify the size (number of 32 bit integers) in the array to lsearch. Size can be from 1K to 4M.

       --malloc N
              start N workers continuously calling malloc(3), calloc(3), realloc(3) and free(3). By default,  up
              to  65536  allocations  can  be active at any point, but this can be altered with the --malloc-max
              option.  Allocation, reallocation and freeing are chosen at random; 50%  of  the  time  memory  is
              allocation (via malloc, calloc or realloc) and 50% of the time allocations are free'd.  Allocation
              sizes are also random, with the maximum allocation size controlled by the  --malloc-bytes  option,
              the default size being 64K.  The worker is re-started if it is killed by the out of mememory (OOM)
              killer.

       --malloc-bytes N
              maximum per allocation/reallocation size. Allocations are randomly selected from 1 to N bytes. One
              can  specify  the size in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.
              Large allocation sizes cause the memory allocator to use mmap(2) rather than  expanding  the  heap
              using brk(2).

       --malloc-max N
              maximum  number  of  active allocations allowed. Allocations are chosen at ramdom and placed in an
              allocation slot. Because about 50%/50% split between allocation and freeing, typically half of the
              allocation slots are in use at any one time.

       --malloc-ops N
              stop  after  N  malloc  bogo  operations.  One  bogo operations relates to a successful malloc(3),
              calloc(3) or realloc(3).

       --malloc-thresh N
              specify the threshold where malloc uses mmap(2) instead of sbrk(2) to allocate more  memory.  This
              is only available on systems that provide the GNU C mallopt(3) tuning function.

       --matrix N
              start  N workers that perform various matrix operations on floating point values. By default, this
              will exercise all the matrix stress methods one by one.  One can specify a specific matrix  stress
              method with the --matrix-method option.

       --matrix-ops N
              stop matrix stress workers after N bogo operations.

       --matrix-method method
              specify a matrix stress method. Available matrix stress methods are described as follows:

              Method           Description
              all              iterate over all the below matrix stress methods
              add              add two N × N matrices
              copy             copy one N × N matrix to another
              div              divide an N × N matrix by a scalar
              hadamard         Hadamard product of two N × N matrices
              frobenius        Frobenius product of two N × N matrices
              mean             arithmetic mean of two N × N matrices
              mult             multiply an N × N matrix by a scalar
              prod             product of two N × N matrices
              sub              subtract one N × N matrix from another N × N matrix
              trans            transpose an N × N matrix

       --matrix-size N
              specify  the  N  ×  N  size  of  the  matrices.  Smaller values result in a floating point compute
              throughput bound stressor, where as large values result in a cache and/or memory  bandwidth  bound
              stressor.

       --membarrier N
              start N workers that exercise the membarrier system call (Linux only).

       --membarrier-ops N
              stop membarrier stress workers after N bogo membarrier operations.

       --memcpy N
              start  N  workers  that copy 2MB of data from a shared region to a buffer using memcpy(3) and then
              move the data in the buffer with memmove(3)  with  3  different  alignments.  This  will  exercise
              processor cache and system memory.

       --memcpy-ops N
              stop memcpy stress workers after N bogo memcpy operations.

       --memfd N
              start  N  workers that create 256 allocations of 1024 pages using memfd_create(2) and ftruncate(2)
              for allocation and mmap(2) to map the allocation into the process address space.  (Linux only).

       --memfd-ops N
              stop after N memfd-create(2) bogo operations.

       --mergesort N
              start N workers that sort 32 bit integers using the BSD mergesort.

       --mergesort-ops N
              stop mergesort stress workers after N bogo mergesorts.

       --mergesort-size N
              specify number of 32 bit integers to sort, default is 262144 (256 × 1024).

       --mincore N
              start N workers that walk through all of memory 1 page at a time checking of the page  mapped  and
              also is resident in memory using mincore(2).

       --mincore-ops N
              stop  after  N  mincore  bogo  operations.  One mincore bogo op is equivalent to a 1000 mincore(2)
              calls.

       --mincore-random
              instead of walking through pages sequentially, select pages  at  random.  The  chosen  address  is
              iterated  over  by shifting it right one place and checked by mincore until the address is less or
              equal to the page size.

       --mknod N
              start N workers that create and remove fifos, empty  files  and  named  sockets  using  mknod  and
              unlink.

       --mknod-ops N
              stop directory thrash workers after N bogo mknod operations.

       --mlock N
              start  N  workers that lock and unlock memory mapped pages using mlock(2), munlock(2), mlockall(2)
              and munlockall(2). This is achieved by the mapping of three contiguous pages and then locking  the
              second  page,  hence  ensuring  non-contiguous  pages are locked . This is then repeated until the
              maximum allowed mlocks or a maximum of 262144 mappings are made.  Next, all  future  mappings  are
              mlocked  and  the  worker attempts to map 262144 pages, then all pages are munlocked and the pages
              are unmapped.

       --mlock-ops N
              stop after N mlock bogo operations.

       --mmap N
              start N workers continuously calling mmap(2)/munmap(2).  The initial  mapping  is  a  large  chunk
              (size  specified  by  --mmap-bytes) followed by pseudo-random 4K unmappings, then pseudo-random 4K
              mappings, and then linear 4K unmappings.  Note that this can cause systems to trip the kernel  OOM
              killer on Linux systems if not enough physical memory and swap is not available.  The MAP_POPULATE
              option is used to populate pages into memory on systems that support this.  By default,  anonymous
              mappings  are  used,  however,  the --mmap-file and --mmap-async options allow one to perform file
              based mappings if desired.

       --mmap-ops N
              stop mmap stress workers after N bogo operations.

       --mmap-async
              enable file based memory mapping and use asynchronous msync'ing on each page, see --mmap-file.

       --mmap-bytes N
              allocate N bytes per mmap stress worker, the default is 256MB. One can specify the size  in  units
              of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --mmap-file
              enable file based memory mapping and by default use synchronous msync'ing on each page.

       --mmap-mprotect
              change  protection  settings  on  each  page  of memory.  Each time a page or a group of pages are
              mapped or remapped then this option will make the  pages  read-only,  write-only,  exec-only,  and
              read-write.

       --mmapfork N
              start N workers that each fork off 32 child processes, each of which tries to allocate some of the
              free memory left in the system (and trying to avoid any swapping).  The child processes then  hint
              that  the allocation will be needed with madvise(2) and then memset it to zero and hint that it is
              no longer needed with madvise before exiting.  This produces significant amounts of VM activity, a
              lot of cache misses and with minimal swapping.

       --mmapfork-ops N
              stop after N mmapfork bogo operations.

       --mmapmany N
              start  N  workers  that attempt to create the maximum allowed per-process memory mappings. This is
              achieved by mapping 3 contiguous pages and then unmapping the  middle  page  hence  splitting  the
              mapping  into two. This is then repeated until the maximum allowed mappings or a maximum of 262144
              mappings are made.

       --mmapmany-ops N
              stop after N mmapmany bogo operations.

       --mremap N
              start N workers continuously calling mmap(2), mremap(2)  and  munmap(2).   The  initial  anonymous
              mapping is a large chunk (size specified by --mremap-bytes) and then iteratively halved in size by
              remapping all the way down to a page size and then back up to the original size.  This  worker  is
              only available for Linux.

       --mremap-ops N
              stop mremap stress workers after N bogo operations.

       --mremap-bytes N
              initially allocate N bytes per remap stress worker, the default is 256MB. One can specify the size
              in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --msg N
              start N sender and receiver processes that continually send and receive messages  using  System  V
              message IPC.

       --msg-ops N
              stop after N bogo message send operations completed.

       --mq N start  N  sender  and  receiver  processes  that continually send and receive messages using POSIX
              message queues. (Linux only).

       --mq-ops N
              stop after N bogo POSIX message send operations completed.

       --mq-size N
              specify size of POSIX message queue. The default size is 10 messages and most Linux  systems  this
              is  the  maximum  allowed  size  for  normal  users. If the given size is greater than the allowed
              message queue size then a warning is issued and the maximum allowed size is used instead.

       --nice N
              start N cpu consuming workers that exercise the available nice levels. Each iteration forks off  a
              child  process  that  runs through the all the nice levels running a busy loop for 0.1 seconds per
              level and then exits.

       --nice-ops N
              stop after N nice bogo nice loops

       --null N
              start N workers writing to /dev/null.

       --null-ops N
              stop null stress workers after N /dev/null bogo write operations.

       --numa N
              start N workers that migrate stressors and a 4MB memory mapped buffer  around  all  the  available
              NUMA  nodes.   This  uses migrate_pages(2) to move the stressors and mbind(2) and move_pages(2) to
              move the pages of the mapped buffer. After each move, the buffer is written to force activity over
              the  bus  which  results  cache misses.  This test will only run on hardware with NUMA enabled and
              more than 1 NUMA node.

       --numa-ops N
              stop NUMA stress workers after N bogo NUMA operations.

       --oom-pipe N
              start N workers that create as many pipes as allowed and  exercise  expanding  and  shrinking  the
              pipes  from the largest pipe size down to a page size. Data is written into the pipes and read out
              again to fill the pipe buffers. With the --aggressive mode enabled the data is not read  out  when
              the pipes are shrunk, causing the kernel to OOM processes aggressively.  Running many instances of
              this stressor will force kernel to OOM processes due to the many large pipe buffer allocations.

       --oom-pipe-ops N
              stop after N bogo pipe expand/shrink operations.

       -o N, --open N
              start N workers that perform open(2) and then close(2) operations on /dev/zero. The maximum  opens
              at  one  time  is  system  defined,  so  the  test will run up to this maximum, or 65536 open file
              descriptors, which ever comes first.

       --open-ops N
              stop the open stress workers after N bogo open operations.

       --personality N
              start N workers that attempt to set personality  and  get  all  the  available  personality  types
              (process execution domain types) via the personality(2) system call. (Linux only).

       --personality-ops N
              stop personality stress workers after N bogo personality operations.

       -p N, --pipe N
              start  N  workers  that  perform large pipe writes and reads to exercise pipe I/O.  This exercises
              memory write and reads as well as context switching.  Each worker has two processes, a reader  and
              a writer.

       --pipe-ops N
              stop pipe stress workers after N bogo pipe write operations.

       --pipe-data-size N
              specifies  the size in bytes of each write to the pipe (range from 4 bytes to 4096 bytes). Setting
              a small data size will cause more writes to be buffered in the pipe, hence  reducing  the  context
              switch rate between the pipe writer and pipe reader processes. Default size is the page size.

       --pipe-size N
              specifies  the  size  of  the  pipe  in  bytes  (for systems that support the F_SETPIPE_SZ fcntl()
              command). Setting a small pipe size will cause the pipe to fill and block more  frequently,  hence
              increasing  the context switch rate between the pipe writer and the pipe reader processes. Default
              size is 512 bytes.

       -P N, --poll N
              start N workers that perform zero timeout polling via the poll(2), select(2) and  sleep(3)  calls.
              This wastes system and user time doing nothing.

       --poll-ops N
              stop poll stress workers after N bogo poll operations.

       --procfs N
              start  N  workers  that  read  files  from /proc and recursively read files from /proc/self (Linux
              only).

       --procfs-ops N
              stop procfs reading after N bogo read operations. Note, since  the  number  of  entries  may  vary
              between kernels, this bogo ops metric is probably very misleading.

       --pthread N
              start  N  workers  that  iteratively creates and terminates multiple pthreads (the default is 1024
              pthreads per worker). In each iteration, each newly created pthread waits  until  the  worker  has
              created all the pthreads and then they all terminate together.

       --pthread-ops N
              stop pthread workers after N bogo pthread create operations.

       --pthread-max N
              create N pthreads per worker. If the product of the number of pthreads by the number of workers is
              greater than the soft limit of allowed pthreads then  the  maximum  is  re-adjusted  down  to  the
              maximum allowed.

       --ptrace N
              start N workers that fork and trace system calls of a child process using ptrace(2).

       --ptrace-ops N
              stop ptracer workers after N bogo system calls are traced.

       -Q, --qsort N
              start N workers that sort 32 bit integers using qsort.

       --qsort-ops N
              stop qsort stress workers after N bogo qsorts.

       --qsort-size N
              specify number of 32 bit integers to sort, default is 262144 (256 × 1024).

       --quota N
              start  N  workers  that  exercise  the  Q_GETQUOTA,  Q_GETFMT,  Q_GETINFO,  Q_GETSTATS  and Q_SYNC
              quotactl(2) commands on all the available mounted block based file systems.

       --quota-ops N
              stop quota stress workers after N bogo quotactl operations.

       --rdrand N
              start N workers that read the Intel hardware random number generator (Intel  Ivybridge  processors
              upwards).

       --rdrand-ops N
              stop  rdrand  stress  workers  after  N  bogo  rdrand  operations  (1  bogo  op = 2048 random bits
              successfully read).

       --readahead N
              start N workers that randomly seeks and performs 512 byte read/write I/O operations on a file with
              readahead. The default file size is 1 GB.  Readaheads and reads are batched into 16 readaheads and
              then 16 reads.

       --readahead-bytes N
              set the size of readahead file, the default is 1 GB. One can specify the size in units  of  Bytes,
              KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --readahead-ops N
              stop readahead stress workers after N bogo read operations.

       --remap N
              start  N  workers  that  map  512  pages and re-order these pages using the deprecated system call
              remap_file_pages(2). Several page re-orderings are exercised: forward, reverse,  random  and  many
              pages to 1 page.

       --remap-ops N
              stop after N remapping bogo operations.

       -R N, --rename N
              start N workers that each create a file and then repeatedly rename it.

       --rename-ops N
              stop rename stress workers after N bogo rename operations.

       --rlimit N
              start  N  workers  that  exceed  CPU  and file size resource imits, generating SIGXCPU and SIGXFSZ
              signals.

       --rlimit-ops N
              stop after N bogo resource limited SIGXCPU and SIGXFSZ signals have been caught.

       --seccomp N
              start N workers that exercise Secure Computing system call filtering. Each  worker  creates  child
              processes that write a short message to /dev/null and then exits. 2% of the child processes have a
              seccomp filter that disallows the write system call and hence it  is  killed  by  seccomp  with  a
              SIGSYS.   Note  that  this  stressor  can  generate many audit log messages each time the child is
              killed.

       --seccomp-ops N
              stop seccomp stress workers after N seccomp filter tests.

       --seek N
              start N workers that randomly seeks and performs 512 byte read/write I/O operations on a file. The
              default file size is 16 GB.

       --seek-ops N
              stop seek stress workers after N bogo seek operations.

       --seek-punch
              punch randomly located 8K holes into the file to cause more extents to force a more demanding seek
              stressor, (Linux only).

       --seek-size N
              specify the size of the file in bytes. Small file sizes allow the  I/O  to  occur  in  the  cache,
              causing  greater  CPU  load. Large file sizes force more I/O operations to drive causing more wait
              time and more I/O on the drive. One can specify the size in units of  Bytes,  KBytes,  MBytes  and
              GBytes using the suffix b, k, m or g.

       --sem N
              start  N workers that perform POSIX semaphore wait and post operations. By default, a parent and 4
              children are started per worker to provide some contention on the semaphore.  This  stresses  fast
              semaphore operations and produces rapid context switching.

       --sem-ops N
              stop semaphore stress workers after N bogo semaphore operations.

       --sem-procs N
              start  N  child  workers per worker to provide contention on the semaphore, the default is 4 and a
              maximum of 64 are allowed.

       --sem-sysv N
              start N workers that perform System V semaphore wait and post operations. By default, a parent and
              4  children are started per worker to provide some contention on the semaphore. This stresses fast
              semaphore operations and produces rapid context switching.

       --sem-sysv-ops N
              stop semaphore stress workers after N bogo System V semaphore operations.

       --sem-sysv-procs N
              start N child processes per worker to provide contention on the System V semaphore, the default is
              4 and a maximum of 64 are allowed.

       --sendfile N
              start N workers that send an empty file to /dev/null. This operation spends nearly all the time in
              the kernel.  The default sendfile size is 4MB.  The sendfile options are for Linux only.

       --sendfile-ops N
              stop sendfile workers after N sendfile bogo operations.

       --sendfile-size S
              specify the size to be copied with each sendfile call. The default size is 4MB.  One  can  specify
              the size in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --shm N
              start  N  workers  that  open  and  allocate  shared  memory objects using the POSIX shared memory
              interfaces.  By default, the test will repeatedly create and destroy  32  shared  memory  objects,
              each of which is 8MB in size.

       --shm-ops N
              stop after N POSIX shared memory create and destroy bogo operations are complete.

       --shm-bytes N
              specify  the  size  of  the POSIX shared memory objects to be created. One can specify the size in
              units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --shm-objs N
              specify the number of shared memory objects to be created.

       --shm-sysv N
              start N workers that allocate shared memory using  the  System  V  shared  memory  interface.   By
              default,  the  test  will repeatedly create and destroy 8 shared memory segments, each of which is
              8MB in size.

       --shm-sysv-ops N
              stop after N shared memory create and destroy bogo operations are complete.

       --shm-sysv-bytes N
              specify the size of the shared memory segment to be created. One can specify the size in units  of
              Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --shm-sysv-segs N
              specify the number of shared memory segments to be created.

       --sigfd N
              start  N  workers  that generate SIGRT signals and are handled by reads by a child process using a
              file descriptor set up using signalfd(2).  (Linux only). This will generate a heavy context switch
              load when all CPUs are fully loaded.

       --sigfd-ops
              stop sigfd workers after N bogo SIGUSR1 signals are sent.

       --sigfpe N
              start N workers that rapidly cause division by zero SIGFPE faults.

       --sigfpe-ops N
              stop sigfpe stress workers after N bogo SIGFPE faults.

       --sigpending N
              start  N workers that check if SIGUSR1 signals are pending. This stressor masks SIGUSR1, generates
              a SIGUSR1 signal and uses sigpending(2) to see if the signal  is  pending.  Then  it  unmasks  the
              signal and checks if the signal is no longer pending.

       --signpending-ops N
              stop sigpending stress workers after N bogo sigpending pending/unpending checks.

       --sigsegv N
              start N workers that rapidly create and catch segmentation faults.

       --sigsegv-ops N
              stop sigsegv stress workers after N bogo segmentation faults.

       --sigsuspend N
              start  N  workers  that  each  spawn off 4 child processes that wait for a SIGUSR1 signal from the
              parent using sigsuspend(2). The parent sends SIGUSR1 signals to each child  in  rapid  succession.
              Each sigsuspend wakeup is counted as one bogo operation.

       --sigsuspend-ops N
              stop sigsuspend stress workers after N bogo sigsuspend wakeups.

       --sigq N
              start  N  workers that rapidly send SIGUSR1 signals using sigqueue(3) to child processes that wait
              for the signal via sigwaitinfo(2).

       --sigq-ops N
              stop sigq stress workers after N bogo signal send operations.

       --sleep N
              start N workers that spawn off multiple threads that each perform multiple sleeps of ranges 1us to
              0.1s.  This creates multiple context switches and timer interrupts.

       --sleep-ops N
              stop after N sleep bogo operations.

       --sleep-max P
              start P threads per worker. The default is 1024, the maximum allowed is 30000.

       -S N, --sock N
              start N workers that perform various socket stress activity. This involves a pair of client/server
              processes performing rapid connect, send and receives and disconnects on the local host.

       --sock-domain D
              specify the domain to use, the default is ipv4. Currently ipv4, ipv6 and unix are supported.

       --sock-nodelay
              This disables the TCP Nagle algorithm, so data segments are always sent as soon as possible.  This
              stops  data  from  being  buffered  before  being  transmitted,  hence resulting in poorer network
              utilisation and more context switches between the sender and receiver.

       --sock-port P
              start at socket port P. For N socket worker processes, ports P to P - 1 are used.

       --sock-ops N
              stop socket stress workers after N bogo operations.

       --sock-opts [ send | sendmsg | sendmmsg ]
              by default, messages are sent using send(2). This option allows one to specify the sending  method
              using  send(2), sendmsg(2) or sendmmsg(2).  Note that sendmmsg is only available for Linux systems
              that support this system call.

       --sockfd N
              start N workers that pass file descriptors over a UNIX domain socket using the  CMSG(3)  ancillary
              data  mechanism. For each worker, pair of client/server processes are created, the server opens as
              many file descriptors on /dev/null as possible and passing these over the socket to a client  that
              reads these from the CMSG data and immediately closes the files.

       --sockfd-ops N
              stop sockfd stress workers after N bogo operations.

       --sockpair N
              start  N  workers  that perform socket pair I/O read/writes. This involves a pair of client/server
              processes performing randomly sized socket I/O operations.

       --sockpair-ops N
              stop socket pair stress workers after N bogo operations.

       --spawn N
              start N workers continually spawn children using posix_spawn(3) that exec stress-ng and then  exit
              almost immediately.

       --spawn-ops N
              stop spawn stress workers after N bogo spawns.

       --splice N
              move  data  from  /dev/zero to /dev/null through a pipe without any copying between kernel address
              space and user address space using splice(2). This is only available for Linux.

       --splice-ops N
              stop after N bogo splice operations.

       --splice-bytes N
              transfer N bytes per splice call, the default is 64K. One can specify the size in units of  Bytes,
              KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --stack N
              start N workers that rapidly cause and catch stack overflows by use of alloca(3).

       --stack-full
              the  default  action is to touch the lowest page on each stack allocation. This option touches all
              the pages by filling the new stack allocation  with  zeros  which  forces  physical  pages  to  be
              allocated and hence is more aggressive.

       --stack-ops N
              stop stack stress workers after N bogo stack overflows.

       --str N
              start N workers that exercise various libc string functions on random strings.

       --str-method strfunc
              select  a  specific libc string function to stress. Available string functions to stress are: all,
              index, rindex, strcasecmp, strcat, strchr, strcoll, strcmp, strcpy, strlen, strncasecmp,  strncat,
              strncmp,  strrchr and strxfrm.  See string(3) for more information on these string functions.  The
              'all' method is the default and will exercise all the string methods.

       --str-ops N
              stop after N bogo string operations.

       --stream N
              start N workers exercising a memory bandwidth stressor loosely based on  the  STREAM  "Sustainable
              Memory Bandwidth in High Performance Computers" benchmarking tool by John D. McCalpin, Ph.D.  This
              stressor allocates buffers that are at least 4 times the size of the CPU L2 cache and  continually
              performs  rounds  of  following  computations  on  large arrays of double precision floating point
              numbers:

              Operation            Description
              copy                 c[i] = a[i]
              scale                b[i] = scalar * c[i]
              add                  c[i] = a[i] + b[i]
              triad                a[i] = b[i] + (c[i] * scalar)

              Since this is loosely based on a variant of the STREAM benchmark code, DO NOT submit results based
              on  this  as it is intended to in stress-ng just to stress memory and compute and NOT intended for
              STREAM accurate tuned or non-tuned benchmarking whatsoever.  Use the official STREAM  benchmarking
              tool if you desire accurate and standardised STREAM benchmarks.

       --stream-ops N
              stop  after  N stream bogo operations, where a bogo operation is one round of copy, scale, add and
              triad operations.

       --stream-l3-size N
              Specify the CPU Level 3 cache size in bytes.  One can specify the size in units of Bytes,  KBytes,
              MBytes  and  GBytes  using  the  suffix  b, k, m or g.  If the L3 cache size is not provided, then
              stress-ng will attempt to determine the cache size, and failing this, will  default  the  size  to
              4MB.

       -s N, --switch N
              start N workers that send messages via pipe to a child to force context switching.

       --switch-ops N
              stop context switching workers after N bogo operations.

       --symlink N
              start N workers creating and removing symbolic links.

       --symlink-ops N
              stop symlink stress workers after N bogo operations.

       --sync-file N
              start  N workers that perform a range of data syncs across a file using sync_file_range(2).  Three
              mixes of syncs are performed, from start to the end of the file,  from end  of  the  file  to  the
              start,  and  a  random  mix.  A  random  selection  of  valid  sync  types  are used, covering the
              SYNC_FILE_RANGE_WAIT_BEFORE, SYNC_FILE_RANGE_WRITE and SYNC_FILE_RANGE_WAIT_AFTER flag bits.

       --sync-file-ops N
              stop sync-file workers after N bogo sync operations.

       --sync-file-bytes N
              specify the size of the file to be sync'd. One can specify the size in  units  of  Bytes,  KBytes,
              MBytes and GBytes using the suffix b, k, m or g.

       --sysinfo N
              start  N  workers  that  continually read system and process specific information.  This reads the
              process user and system times using the times(2) system call.  For Linux systems,  it  also  reads
              overall system statistics using the sysinfo(2) system call and also the file system statistics for
              all mounted file systems using statfs(2).

       --sysinfo-ops N
              stop the sysinfo workers after N bogo operations.

       --sysfs N
              start N workers that recursively read files from /sys  (Linux  only).   This  may  cause  specific
              kernel drivers to emit messages into the kernel log.

       --sys-ops N
              stop  sysfs  reading  after  N  bogo  read  operations. Note, since the number of entries may vary
              between kernels, this bogo ops metric is probably very misleading.

       --tee N
              move data from a writer process to a reader process through pipes and  to  /dev/null  without  any
              copying  between  kernel address space and user address space using tee(2). This is only available
              for Linux.

       --tee-ops N
              stop after N bogo tee operations.

       -T N, --timer N
              start N workers creating timer events at a default rate of 1 MHz (Linux only); this can  create  a
              many  thousands  of  timer  clock  interrupts.  Each timer event is caught by a signal handler and
              counted as a bogo timer op.

       --timer-ops N
              stop timer stress workers after N bogo timer events (Linux only).

       --timer-freq F
              run timers at F Hz; range from 1 to 1000000000  Hz  (Linux  only).  By  selecting  an  appropriate
              frequency stress-ng can generate hundreds of thousands of interrupts per second.

       --timer-rand
              select  a  timer frequency based around the timer frequency +/- 12.5% random jitter. This tries to
              force more variability in the timer interval to make the scheduling less predictable.

       --timerfd N
              start N workers creating timerfd events at a default rate of 1 MHz (Linux only); this can create a
              many  thousands  of  timer  clock events. Timer events are waited for on the timer file descriptor
              using select(2) and then read and counted as a bogo timerfd op.

       --timerfd-ops N
              stop timerfd stress workers after N bogo timerfd events (Linux only).

       --timerfd-freq F
              run timers at F Hz; range from 1 to 1000000000  Hz  (Linux  only).  By  selecting  an  appropriate
              frequency stress-ng can generate hundreds of thousands of interrupts per second.

       --timerfd-rand
              select a timerfd frequency based around the timer frequency +/- 12.5% random jitter. This tries to
              force more variability in the timer interval to make the scheduling less predictable.

       --tsc N
              start N workers that read the Time  Stamp  Counter  (TSC)  256  times  per  loop  iteration  (bogo
              operation). Available only on Intel x86 platforms.

       --tsc-ops N
              stop the tsc workers after N bogo operations are completed.

       --tsearch N
              start  N workers that insert, search and delete 32 bit integers on a binary tree using tsearch(3),
              tfind(3) and tdelete(3). By default, there are 65536 randomized integers used in the  tree.   This
              is a useful method to exercise random access of memory and processor cache.

       --tsearch-ops N
              stop the tsearch workers after N bogo tree operations are completed.

       --tsearch-size N
              specify the size (number of 32 bit integers) in the array to tsearch. Size can be from 1K to 4M.

       --udp N
              start  N  workers  that  transmit  data using UDP. This involves a pair of client/server processes
              performing rapid connect, send and receives and disconnects on the local host.

       --udp-domain D
              specify the domain to use, the default is ipv4. Currently ipv4, ipv6 and unix are supported.

       --udp-lite
              use the UDP-Lite (RFC 3828) protocol (only for ipv4 and ipv4 domains).

       --udp-ops N
              stop udp stress workers after N bogo operations.

       --udp-port P
              start at port P. For N udp worker processes, ports P to P - 1 are used.  By  default,  ports  7000
              upwards are used.

       --udp-flood N
              start N workers that attempt to flood the host with UDP packets to random ports. The IP address of
              the packets are currently not spoofed. This is only available on systems that support AF_PACKET.

       --udp-flood-domain D
              specify the domain to use, the default is ipv4. Currently ipv4 and ipv6 are supported.

       --udp-flood-ops N
              stop udp-flood stress workers after N bogo operations.

       --unshare N
              start N workers that each fork off 32 child processes, each  of  which  exercises  the  unshare(2)
              system call by disassociating parts of the process execution context. (Linux only).

       --unshare-ops N
              stop after N bogo unshare operations.

       -u N, --urandom N
              start N workers reading /dev/urandom (Linux only). This will load the kernel random number source.

       --urandom-ops N
              stop urandom stress workers after N urandom bogo read operations (Linux only).

       --userfaultfd N
              start  N  workers  that generate write page faults on a small anonymously mapped memory region and
              handle these faults using the user space fault handling via the userfaultfd mechanism.  This  will
              generate a large quanity of major page faults and also context switches during the handling of the
              page faults.  (Linux only).

       --userfaultfd-ops N
              stop userfaultfd stress workers after N page faults.

       --userfaultfd-bytes N
              mmap N bytes per userfaultfd worker to page fault on, the default is 16MB One can specify the size
              in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --utime N
              start N workers updating file timestamps. This is mainly CPU bound when the default is used as the
              system flushes metadata changes only periodically.

       --utime-ops N
              stop utime stress workers after N utime bogo operations.

       --utime-fsync
              force metadata changes on each file timestamp update to be flushed to disk.  This forces the  test
              to become I/O bound and will result in many dirty metadata writes.

       --vecmath N
              start  N workers that perform various unsigned integer math operations on various 128 bit vectors.
              A mix of vector math operations are performed on the following vectors: 16 × 8 bits, 8 × 16  bits,
              4  ×  32  bits, 2 × 64 bits. The metrics produced by this mix depend on the processor architecture
              and the vector math optimisations produced by the compiler.

       --vecmath-ops N
              stop after N bogo vector integer math operations.

       --vfork N
              start N workers continually vforking children that immediately exit.

       --vfork-ops N
              stop vfork stress workers after N bogo operations.

       --vfork-max P
              create P processes and then wait for them to exit per iteration. The default  is  just  1;  higher
              values  will  create  many  temporary  zombie  processes  that  are  waiting to be reaped. One can
              potentially fill up the the process table using high values for --vfork-max and --vfork.

       -m N, --vm N
              start N workers continuously calling mmap(2)/munmap(2) and writing to the allocated  memory.  Note
              that  this can cause systems to trip the kernel OOM killer on Linux systems if not enough physical
              memory and swap is not available.

       --vm-bytes N
              mmap N bytes per vm worker, the default is 256MB. One can specify the  size  in  units  of  Bytes,
              KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --vm-stride N
              deprecated since version 0.03.02

       --vm-ops N
              stop vm workers after N bogo operations.

       --vm-hang N
              sleep  N  seconds  before  unmapping memory, the default is zero seconds.  Specifying 0 will do an
              infinite wait.

       --vm-keep
              do not continually unmap and map memory, just keep on re-writing to it.

       --vm-locked
              Lock the pages of the mapped region into memory using mmap MAP_LOCKED (since Linux 2.5.37).   This
              is similar to locking memory as described in mlock(2).

       --vm-method m
              specify a vm stress method. By default, all the stress methods are exercised sequentially, however
              one can specify just one method to be used if required.  Each of the vm workers have 3 phases:

              1. Initialised. The anonymously memory mapped region is set to a known pattern.

              2. Exercised. Memory is modified in  a  known  predictable  way.  Some  vm  workers  alter  memory
              sequentially, some use small or large strides to step along memory.

              3. Checked. The modified memory is checked to see if it matches the expected result.

              The vm methods containing 'prime' in their name have a stride of the largest prime less than 2^64,
              allowing to them to thoroughly step through memory and touch all locations just  once  while  also
              doing without touching memory cells next to each other. This strategy exercises the cache and page
              non-locality.

              Since the memory being exercised is virtually mapped then there is no guarantee of  touching  page
              addresses in any particular physical order.  These workers should not be used to test that all the
              system's memory is working correctly either, use tools such as memtest86 instead.

              The vm stress methods are intended to exercise memory in ways to possibly find memory  issues  and
              to try to force thermal errors.

              Available vm stress methods are described as follows:

              Method                  Description
              all                     iterate over all the vm stress methods as listed below.
              flip                    sequentially work through memory 8 times, each time just one bit in memory
                                      flipped (inverted). This will effectively invert each byte in 8 passes.
              galpat-0                galloping pattern zeros. This sets all bits to 0 and flips just 1 in  4096
                                      bits  to  1. It then checks to see if the 1s are pulled down to 0 by their
                                      neighbours or of the neighbours have been pulled up to 1.
              galpat-1                galloping pattern ones. This sets all bits to 1 and flips just 1  in  4096
                                      bits  to  0.  It  then checks to see if the 0s are pulled up to 1 by their
                                      neighbours or of the neighbours have been pulled down to 0.
              gray                    fill the memory with sequential gray codes (these only change 1 bit  at  a
                                      time between adjacent bytes) and then check if they are set correctly.
              incdec                  work  sequentially  through  memory  twice, the first pass increments each
                                      byte by a specific value and the second pass decrements each byte back  to
                                      the  original  start  value. The increment/decrement value changes on each
                                      invocation of the stressor.
              inc-nybble              initialise memory to a set value (that changes on each invocation  of  the
                                      stressor)  and  then  sequentially work through each byte incrementing the
                                      bottom 4 bits by 1 and the top 4 bits by 15.
              rand-set                sequentially work through memory in 64 bit chunks  setting  bytes  in  the
                                      chunk  to  the  same 8 bit random value.  The random value changes on each
                                      chunk.  Check that the values have not changed.
              rand-sum                sequentially set all memory to random values and then summate  the  number
                                      of bits that have changed from the original set values.

              read64                  sequentially  read memory using 32 x 64 bit reads per bogo loop. Each loop
                                      equates to one bogo operation.  This exercises raw memory reads.
              ror                     fill memory with a random pattern and then sequentially rotate 64 bits  of
                                      memory right by one bit, then check the final load/rotate/stored values.
              swap                    fill  memory  in  64  byte  chunks with random patterns. Then swap each 64
                                      chunk with a randomly chosen chunk. Finally, reverse the swap to  put  the
                                      chunks back to their original place and check if the data is correct. This
                                      exercises adjacent and random memory load/stores.
              move-inv                sequentially fill memory 64 bits of memory at a time with  random  values,
                                      and  then check if the memory is set correctly.  Next, sequentially invert
                                      each 64 bit pattern and again check if the memory is set as expected.
              modulo-x                fill memory over 23 iterations. Each iteration  starts  one  byte  further
                                      along  from the start of the memory and steps along in 23 byte strides. In
                                      each stride, the first byte is set to a random pattern and all other bytes
                                      are set to the inverse.  Then it checks see if the first byte contains the
                                      expected random pattern. This  exercises  cache  store/reads  as  well  as
                                      seeing if neighbouring cells influence each other.
              prime-0                 iterate  8  times  by  stepping through memory in very large prime strides
                                      clearing just on bit at a time in every byte. Then check  to  see  if  all
                                      bits are set to zero.
              prime-1                 iterate  8  times  by  stepping through memory in very large prime strides
                                      setting just on bit at a time in every byte. Then check to see if all bits
                                      are set to one.
              prime-gray-0            first step through memory in very large prime strides clearing just on bit
                                      (based on a gray code) in every byte. Next,  repeat  this  but  clear  the
                                      other 7 bits. Then check to see if all bits are set to zero.
              prime-gray-1            first  step through memory in very large prime strides setting just on bit
                                      (based on a gray code) in every byte. Next, repeat this but set the  other
                                      7 bits. Then check to see if all bits are set to one.
              rowhammer               try  to  force memory corruption using the rowhammer memory stressor. This
                                      fetches two 32 bit integers from memory and forces a cache  flush  on  the
                                      two addresses multiple times. This has been known to force bit flipping on
                                      some hardware, especially with lower frequency memory refresh cycles.
              walk-0d                 for each byte in memory, walk through each data line setting them  to  low
                                      (and  the  others  are  set  high)  and check that the written value is as
                                      expected. This checks if any data lines are stuck.
              walk-1d                 for each byte in memory, walk through each data line setting them to  high
                                      (and  the  others  are  set  low)  and  check that the written value is as
                                      expected. This checks if any data lines are stuck.
              walk-0a                 in the given memory mapping, work through  a  range  of  specially  chosen
                                      addresses  working  through  address lines to see if any address lines are
                                      stuck low. This works  best  with  physical  memory  addressing,  however,
                                      exercising these virtual addresses has some value too.
              walk-1a                 in  the  given  memory  mapping,  work through a range of specially chosen
                                      addresses working through address lines to see if any  address  lines  are
                                      stuck  high.  This  works  best  with physical memory addressing, however,
                                      exercising these virtual addresses has some value too.
              write64                 sequentially write memory using 32 x 64 bit writes  per  bogo  loop.  Each
                                      loop  equates  to  one  bogo operation.  This exercises raw memory writes.
                                      Note that memory writes are not checked at the end of each test iteration.
              zero-one                set all memory bits to zero and then check if any bits are not zero. Next,
                                      set all the memory bits to one and check if any bits are not one.

       --vm-populate
              populate  (prefault) page tables for the memory mappings; this can stress swapping. Only available
              on systems that support MAP_POPULATE (since Linux 2.5.46).

       --vm-rw N
              start N workers that  transfer  memory  to/from  a  parent/child  using  process_vm_writev(2)  and
              process_vm_readv(2).  This  is  feature  is  only  supported  on Linux.  Memory transfers are only
              verified if the --verify option is enabled.

       --vm-rw-ops N
              stop vm-rw workers after N memory read/writes.

       --vm-rw-bytes N
              mmap N bytes per vm-rw worker, the default is 16MB. One can specify the size in  units  of  Bytes,
              KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --vm-splice N
              move data from memory to /dev/null through a pipe without any copying between kernel address space
              and user address space using vmsplice(2) and splice(2).  This is only available for Linux.

       --vm-splice-ops N
              stop after N bogo vm-splice operations.

       --vm-splice-bytes N
              transfer N bytes per vmsplice call, the default is 64K. One can  specify  the  size  in  units  of
              Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

       --wait N
              start  N  workers that spawn off two children; one spins in a pause(2) loop, the other continually
              stops and continues the first. The controlling process waits on the first child to be  resumed  by
              the delivery of SIGCONT using waitpid(2) and waitid(2).

       --wait-ops N
              stop after N bogo wait operations.

       --wcs N
              start N workers that exercise various libc wide character string functions on random strings.

       --wcs-method wcsfunc
              select  a  specific  libc  wide character string function to stress. Available string functions to
              stress are: all,  wcscasecmp,  wcscat,  wcschr,  wcscoll,  wcscmp,  wcscpy,  wcslen,  wcsncasecmp,
              wcsncat,  wcsncmp, wcsrchr and wcsxfrm.  The 'all' method is the default and will exercise all the
              string methods.

       --wcs-ops N
              stop after N bogo wide character string operations.

       --xattr N
              start N workers that create, update and delete batches of extended attributes on a file.

       --xattr-ops N
              stop after N bogo extended attribute operations.

       -y N, --yield N
              start N workers that call sched_yield(2). This stressor ensures that at least  2  child  processes
              per  CPU  exercice  shield_yield(2) no matter how many workers are specified, thus always ensuring
              rapid context switching.

       --yield-ops N
              stop yield stress workers after N sched_yield(2) bogo operations.

       --zero N
              start N workers reading /dev/zero.

       --zero-ops N
              stop zero stress workers after N /dev/zero bogo read operations.

       --zlib N
              start N workers compressing and  decompressing  random  data  using  zlib.  Each  worker  has  two
              processes,  one  that compresses random data and pipes it to another process that decompresses the
              data. This stressor exercises CPU, cache and memory.

       --zlib-ops N
              stop after N bogo compression operations, each bogo compression operation is a compression of  64K
              of random data at the highest compression level.

       --zombie N
              start  N  workers  that create zombie processes. This will rapidly try to create a default of 8192
              child processes that immediately die and wait in a zombie state until they are reaped.   Once  the
              maximum  number of processes is reached (or fork fails because one has reached the maximum allowed
              number of children) the oldest child is reaped and a new process is then  created  in  a  first-in
              first-out manner, and then repeated.

       --zombie-ops N
              stop zombie stress workers after N bogo zombie operations.

       --zombie-max N
              try  to  create as many as N zombie processes. This may not be reached if the system limit is less
              than N.

EXAMPLES

       stress-ng --cpu 4 --io 2 --vm 1 --vm-bytes 1G --timeout 60s

              runs for 60 seconds with 4 cpu stressors, 2 io stressors and 1 vm stressor using  1GB  of  virtual
              memory.

       stress-ng --cpu 8 --cpu-ops 800000

              runs 8 cpu stressors and stops after 800000 bogo operations.

       stress-ng --sequential 2 --timeout 2m --metrics

              run  2 simultaneous instances of all the stressors sequentially one by one, each for 2 minutes and
              summarise with performance metrics at the end.

       stress-ng --cpu 4 --cpu-method fft --cpu-ops 10000 --metrics-brief

              run 4 FFT cpu stressors, stop after 10000 bogo operations and produce a summary just for  the  FFT
              results.

       stress-ng --cpu 0 --cpu-method all -t 1h

              run cpu stressors on all online CPUs working through all the available CPU stressors for 1 hour.

       stress-ng --all 4 --timeout 5m

              run 4 instances of all the stressors for 5 minutes.

       stress-ng --random 64

              run 64 stressors that are randomly chosen from all the available stressors.

       stress-ng --cpu 64 --cpu-method all --verify -t 10m --metrics-brief

              run  64  instances of all the different cpu stressors and verify that the computations are correct
              for 10 minutes with a bogo operations summary at the end.

       stress-ng --sequential 0 -t 10m

              run all the stressors one by one for 10 minutes, with the number of  instances  of  each  stressor
              matching the number of online CPUs.

       stress-ng --sequential 8 --class io -t 5m --times

              run  all  the  stressors  in  the io class one by one for 5 minutes each, with 8 instances of each
              stressor running concurrently and show overall time utilisation statistics at the end of the run.

       stress-ng --all 0 --maximize --aggressive

              run all the stressors (1 instance of each per CPU) simultaneously, maximize the  settings  (memory
              sizes, file allocations, etc.) and select the most demanding/aggressive options.

       stress-ng --random 32 -x numa,hdd,key

              run 32 randomly selected stressors and exclude the numa, hdd and key stressors

       stress-ng --sequential 4 --class vm --exclude bigheap,brk,stack

              run  4  instances  of  the VM stressors one after each other, excluding the bigheap, brk and stack
              stressors

EXIT STATUS

         Status     Description
           0        Success.
           1        Error; incorrect user options or a fatal resource issue in the  stress-ng  stressor  harness
                    (for example, out of memory).
           2        One or more stressors failed.
           3        One  or more stressors failed to initialise because of lack of resources, for example ENOMEM
                    (no memory) and ENOSPC (no space on file system).

BUGS

       File bug reports at:
         https://launchpad.net/ubuntu/+source/stress-ng/+filebug

SEE ALSO

       bsearch(3),  fallocate(2),  fcntl(2),  flock(2),  ftruncate(2),  hsearch(3),  ionice(1),   ioprio_set(2),
       lsearch(3),  perf(1),  pthreads(7), qsort(3), sched_yield(2), sched_setaffinity(2), stress(1), splice(2),
       tsearch(3)

AUTHOR

       stress-ng was written by Colin King <colin.king@canonical.com> and is a clean room re-implementation  and
       extension  of  the  original  stress  tool  by  Amos  Waterland <apw@rossby.metr.ou.edu>. Thanks also for
       contributions from Christian Ehrhardt, James Hunt, Tim Gardner and Luca Pizzamiglio.

NOTES

       Note that the stress-ng cpu, io, vm and hdd tests are different implementations of  the  original  stress
       tests  and hence may produce different stress characteristics.  stress-ng does not support any GPU stress
       tests.

       The bogo operations metrics may change with each release  because of bug fixes to the code, new features,
       compiler optimisations or changes in system call performance.

COPYRIGHT

       Copyright © 2013-2016 Canonical Ltd.
       This  is  free  software;  see  the  source  for  copying conditions.  There is NO warranty; not even for
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

                                                 March 12, 2016                                     STRESS-NG(1)