Provided by: stress-ng_0.05.23-1ubuntu2_amd64 
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)