--mq N

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

--race-sched-ops N

stop after N process creation bogo-operations.

Radixsort stressor

--radixsort N

start N workers that sort random 8 byte strings using radixsort.

--radixsort-method [ radixsort-libc | radixsort-nonlibc ]

select either the libc implementation of radixsort or an optimized implementation of radixsort. The default is the libc implementation if it is available.

--radixsort-ops N

stop radixsort stress workers after N bogo radixsorts.

--radixsort-size N

specify number of strings to sort, default is 262144 (256 × 1024).

Memory filesystem stressor

--ramfs N

start N workers mounting a memory based file system using ramfs and tmpfs (Linux only). This alternates between mounting and umounting a ramfs or tmpfs file system using the traditional mount(2) and umount(2) system call as well as the newer Linux 5.2 fsopen(2), fsmount(2), fsconfig(2) and move_mount(2) system calls if they are available. The default ram file system size is 2 MB.

--ramfs-fill

fill ramfs with zero’d data using fallocate(2) if it is available or multiple calls to write(2) if not.

--ramfs-ops N

stop after N ramfs mount operations.

--ramfs-size N

set the ramfs size (must be multiples of the page size).

Raw device stressor

--rawdev N

start N workers that read the underlying raw drive device using direct IO reads. The device (with minor number 0) that stores the current working directory is the raw device to be read by the stressor. The read size is exactly the size of the underlying device block size. By default, this stressor will exercise all the of the rawdev methods (see the --rawdev-method option). This is a Linux only stressor and requires root privilege to be able to read the raw device.

--rawdev-method method

Available rawdev stress methods are described as follows:

--rawdev-ops N

stop the rawdev stress workers after N raw device read bogo operations.

Random list stressor

--randlist N

start N workers that creates a list of objects in randomized memory order and traverses the list setting and reading the objects. This is designed to exerise memory and cache thrashing. Normally the objects are allocated on the heap, however for objects of page size or larger there is a 1 in 16 chance of objects being allocated using shared anonymous memory mapping to mix up the address spaces of the allocations to create more TLB thrashing.

--randist-compact

Allocate all the list objects using one large heap allocation and divide this up for all the list objects. This removes the overhead of the heap keeping track of each list object, hence uses less memory.

--randlist-items N

Allocate N items on the list. By default, 100,000 items are allocated.

--randlist-ops N

stop randlist workers after N list traversals

--randlist-size N

Allocate each item to be N bytes in size. By default, the size is 64 bytes of data payload plus the list handling pointer overhead.

Localhost raw socket stressor

--rawsock N

start N workers that send and receive packet data using raw sockets on the localhost. Requires CAP_NET_RAW to run.

--rawsock-ops N

stop rawsock workers after N packets are received.

--rawsock-port P

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

Localhost ethernet raw packets stressor

--rawpkt N

start N workers that sends and receives ethernet packets using raw packets on the localhost via the loopback device. Requires CAP_NET_RAW to run.

--rawpkt-ops N

stop rawpkt workers after N packets from the sender process are received.

--rawpkt-port N

start at port P. For N rawpkt worker processes, ports P to (P × 4) − 1 are used. The default starting port is port 14000.

--rawpkt-rxring N

setup raw packets with RX ring with N number of blocks, this selects TPACKET_V. N must be one of 1, 2, 4, 8 or 16.

Localhost raw UDP packet stressor

--rawudp N

start N workers that send and receive UDP packets using raw sockets on the localhost. Requires CAP_NET_RAW to run.

--rawudp-if NAME

use network interface NAME. If the interface NAME does not exist, is not up or does not support the domain then the loopback (lo) interface is used as the default.

--rawudp-ops N

stop rawudp workers after N packets are received.

--rawudp-port N

start at port P. For N rawudp worker processes, ports P to (P × 4) - 1 are used. The default starting port is port 13000.

Random number generator stressor

--rdrand N

start N workers that read a random number from an on-chip random number generator This uses the rdrand instruction on Intel x86 processors or the darn instruction on Power9 processors.

--rdrand-ops N

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

--rdrand-seed

use rdseed instead of rdrand (x86 only).

Read-ahead stressor

--readahead N

start N workers that randomly seek and perform 4096 byte read/write I/O operations on a file with readahead. The default file size is 64 MB. 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 as % of free space on the file system or 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.

Reboot stressor

--reboot N

start N workers that exercise the reboot(2) system call. When possible, it will create a process in a PID namespace and perform a reboot power off command that should shutdown the process. Also, the stressor exercises invalid reboot magic values and invalid reboots when there are insufficient privileges that will not actually reboot the system.

--reboot-ops N

stop the reboot stress workers after N bogo reboot cycles.

POSIX regular expressions stressor

--regex N

start N workers that compile various POSIX regular expressions and execute them against a set of text strings. This exercises the regex C library with a range of various simple and complex regex expressions.

--regex-ops N

stop after N regex compilations.

CPU registers stressor

--regs N

start N workers that shuffle data around the CPU registers exercising register move instructions. Each bogo-op represents 1000 calls of a shuffling function that shuffles the registers 32 times. Only implemented for the GCC compiler since this requires register annotations and optimization level 0 to compile appropriately.

--regs-ops N

stop regs stressors after N bogo operations.

Memory page reordering stressor

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

attempt to mlock mmap’d huge pages into memory causing more memory pressure by preventing pages from swapped out.

--remap-ops N

stop after N remapping bogo operations.

--remap-pages N

specify number of pages to remap, must be a power of 2, default is 512 pages.

Renaming file stressor

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

Process rescheduling stressor

--resched N

start N workers that exercise process rescheduling. Each stressor spawns a child process for each of the positive nice levels and iterates over the nice levels from 0 to the lowest priority level (highest nice value). For each of the nice levels 1024 iterations over 3 non-real time scheduling polices SCHED_OTHER, SCHED_BATCH and SCHED_IDLE are set and a sched_yield occurs to force heavy rescheduling activity. When the -v verbose option is used the distribution of the number of yields across the nice levels is printed for the first stressor out of the N stressors.

--resched-ops N

stop after N rescheduling sched_yield calls.

System resources stressor

--resources N

start N workers that consume various system resources. Each worker will spawn 1024 child processes that iterate 1024 times consuming shared memory, heap, stack, temporary files and various file descriptors (eventfds, memoryfds, userfaultfds, pipes and sockets).

--resources-mlock

attempt to mlock mmap’d pages into memory causing more memory pressure by preventing pages from swapped out.

--resources-ops N

stop after N resource child forks.

Writing temporary files in reverse position stressor

--revio N

start N workers continually writing in reverse position order to temporary files. The default mode is to stress test reverse position ordered writes with randomly sized sparse holes between each write. With the --aggressive option enabled without any --revio-opts options the revio stressor will work through all the --revio-opt options one by one to cover a range of I/O options.

--revio-bytes N

write N bytes for each revio process, the default is 1 GB. One can specify the size as % of free space on the file system or in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

--revio-opts list

specify various stress test options as a comma separated list. Options are the same as --hdd-opts but without the iovec option and with a readahead option to force a readahead action over the entire file once it has been completely written.

--revio-ops N

stop revio stress workers after N bogo operations.

--revio-write-size N

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

Ring pipes stressor

--ring-pipe N

start N workers that move data around a ring of pipes using poll to detect when data is ready to copy. By default, 256 pipes are used with two 4096 byte items of data being copied around the ring of pipes. Data is copied using read and write system calls. If the splice system call is available then one can use splice to use more efficient in-kernel data passing instead of buffer copying.

--ring-pipe-num N

specify the number of pipes to use. Ranges from 4 to 262144, default is 256.

--ring-pipe-ops N

stop after N pipe data transfers.

--ring-pipe-size N

specify the size of data being copied in bytes. Ranges from 1 to 4096, default is 4096.

--ring-pipe-splice

enable splice to move data between pipes (only if splice() is available).

Rlimit stressor

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

VM reverse-mapping stressor

--rmap N

start N workers that exercise the VM reverse-mapping. This creates 16 processes per worker that write/read multiple file-backed memory mappings. There are 64 lots of 4 page mappings made onto the file, with each mapping overlapping the previous by 3 pages and at least 1 page of non-mapped memory between each of the mappings. Data is synchronously msync’d to the file 1 in every 256 iterations in a random manner.

--rmap-ops N

stop after N bogo rmap memory writes/reads.

1 bit rotation stressor

--rotate N

start N workers that exercise 1 bit rotates left and right of unsigned integer variables. The default will rotate four 8, 16, 32, 64 (and if supported 128) bit values 10000 times in a loop per bogo-op.

--rotate-method method

specify the method of rotation to use. The ‘all’ method uses all the methods and is the default.

--rotate-ops N

stop after N bogo rotate operations.

Restartable sequences (rseq) stressor (Linux)

--rseq N

start N workers that exercise restartable sequences via the rseq(2) system call. This loops over a long duration critical section that is likely to be interrupted. A rseq abort handler keeps count of the number of interruptions and a SIGSEV handler also tracks any failed rseq aborts that can occur if there is a mismatch in a rseq check signature. Linux only.

--rseq-ops N

stop after N bogo rseq operations. Each bogo rseq operation is equivalent to 10000 iterations over a long duration rseq handled critical section.

Real-time clock stressor

--rtc N

start N workers that exercise the real time clock (RTC) interfaces via /dev/rtc and /sys/class/rtc/rtc0. No destructive writes (modifications) are performed on the RTC. This is a Linux only stressor.

--rtc-ops N

stop after N bogo RTC interface accesses.

Fast process rescheduling stressor

--schedmix N

start N workers that each start child processes that repeatedly select random a scheduling policy and then executes a short duration randomly chosen time consuming activity. This exercises rapid re-scheduling of processes and generates a large amount of scheduling timer interrupts.

--schedmix-ops N

stop after N scheduling mixed operations.

--schedmix-procs N

specify the number of chid processes to run for each stressor instance, range from 1 to 64, default is 16.

Scheduling policy stressor

--schedpolicy N

start N workers that set the worker to various available scheduling policies out of SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_FIFO, SCHED_RR, SCHED_DEADLINE and SCHED_EXT. For the real time scheduling policies a random sched priority is selected between the minimum and maximum scheduling priority settings.

--schedpolicy-ops N

stop after N bogo scheduling policy changes.

--schedpolicy-rand

Select scheduling policy randomly so that the new policy is always different to the previous policy. The default is to work through the scheduling policies sequentially.

Stream control transmission protocol (SCTP) stressor

--sctp N

start N workers that perform network sctp stress activity using the Stream Control Transmission Protocol (SCTP). This involves client/server processes performing rapid connect, send/receives and disconnects on the local host.

--sctp-domain D

specify the domain to use, the default is ipv4. Currently ipv4 and ipv6 are supported.

--sctp-if NAME

use network interface NAME. If the interface NAME does not exist, is not up or does not support the domain then the loopback (lo) interface is used as the default.

--sctp-ops N

stop sctp workers after N bogo operations.

--sctp-port P

start at sctp port P. For N sctp 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.

--sctp-sched [ fc | fcfs | prio | rr | wfq ]

specify SCTP scheduler, one of fc (fair capacity), fcfs (first come first served, the default), prio (priority), rr (round-robin) or wfq (weighted fair queueing)

File sealing (SEAL) stressor (Linux)

--seal N

start N workers that exercise the fcntl(2) SEAL commands on a small anonymous file created using memfd_create(2). After each SEAL command is issued the stressor also sanity checks if the seal operation has sealed the file correctly. (Linux only).

--seal-ops N

stop after N bogo seal operations.

Secure computing stressor

--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. Requires CAP_SYS_ADMIN to run.

--seccomp-ops N

stop seccomp stress workers after N seccomp filter tests.

Secret memory stressor (Linux ≥ 5.11)

--secretmem N

start N workers that mmap pages using file mapping off a memfd_secret file descriptor. Each stress loop iteration will expand the mappable region by 3 pages using ftruncate and mmap and touches the pages. The pages are then fragmented by unmapping the middle page and then umapping the first and last pages. This tries to force page fragmentation and also trigger out of memory (OOM) kills of the stressor when the secret memory is exhausted. Note this is a Linux 5.11+ only stressor and the kernel needs to be booted with "secretmem=" option to allocate a secret memory reservation.

--secretmem-ops N

stop secretmem stress workers after N stress loop iterations.

IO seek stressor

--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 8 K 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.

POSIX semaphore stressor

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

share the semaphore across all sem stressor instances. Normally each semaphore stressor shares a semaphore with its child processes, this option produces more locking contention and less throughput by sharing a semaphore across all semaphore stressor processes.

System V semaphore stressor

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

--sem-sysv-setall

sets the semval values for all the semaphores in the child’s semaphore set. This depends on the semctl SETALL op being defined and GETALL succeeding and is an opt-in option as it will affect the semaphore being exercised.

Sendfile stressor

--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 4 MB. 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 4 MB. One can specify the size in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

Sessions stressor

--session N

start N workers that create child and grandchild processes that set and get their session ids. 25% of the grandchild processes are not waited for by the child to create orphaned sessions that need to be reaped by init.

--session-ops N

stop session workers after N child processes are spawned and reaped.

Setting data in the Kernel stressor

--set N

start N workers that call system calls that try to set data in the kernel, currently these are: setgid, sethostname, setpgid, setpgrp, setuid, setgroups, setreuid, setregid, setresuid, setresgid and setrlimit. Some of these system calls are OS specific.

--set-ops N

stop set workers after N bogo set operations.

Shellsort stressor

--shellsort N

start N workers that sort 32 bit integers using shellsort.

--shellsort-ops N

stop shellsort stress workers after N bogo shellsorts.

--shellsort-size N

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

POSIX shared memory stressor

--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 8 MB in size.

--shm-bytes N

specify the size of the POSIX shared memory objects to be created. One can specify the size as % of total available memory or in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

--shm-mlock

attempt to mlock shared memory objects into memory causing more memory pressure by preventing pages from swapped out.

--shm-objs N

specify the number of shared memory objects to be created.

--shm-ops N

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

System V shared memory stressor

--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 8 MB in size.

--shm-sysv-bytes N

specify the size of the shared memory segment to be created. One can specify the size as % of total available memory or in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

--shm-sysv-mlock

attempt to mlock shared memory segment into memory causing more memory pressure by preventing pages from swapped out.

--shm-sysv-ops N

stop after N shared memory create and destroy bogo operations are complete.

--shm-sysv-segs N

specify the number of shared memory segments to be created. The default is 8 segments.

SIGABRT stressor

--sigabrt N

start N workers that create children that are killed by SIGABRT signals or by calling abort(3).

--sigabrt-ops N

stop the sigabrt workers after N SIGABRT signals are successfully handled.

SIGBUS stressor

--sigbus N

start N workers that rapidly create and catch bus errors generated via misaligned access and accessing a file backed memory mapping that does not have file storage to back the page being accessed.

--sigbus-ops N

stop sigbus stress workers after N bogo bus errors.

SIGCHLD stressor

--sigchld N

start N workers that create children to generate SIGCHLD signals. This exercises children that exit (CLD_EXITED), get killed (CLD_KILLED), get stopped (CLD_STOPPED) or continued (CLD_CONTINUED).

--sigchld-ops N

stop the sigchld workers after N SIGCHLD signals are successfully handled.

SIGFD stressor (Linux)

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

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

SIGHUP stressor

--sighup N

start N workers that generate SIGHUP signals using raise(2) and by killing a group leader process with a child process indirectly receiving SIGHUP when it loses the group leader.

--sighup-ops N

stop sighup stressor workers after N SIGHUP signals

SIGILL stressor

--sigill N

start N workers that execute illegal instructions to generate SIGILL signals.

--sigill-ops N

stop sigill stressor workers after N SIGILL signals

SIGIO stressor

--sigio N

start N workers that read data from a child process via a pipe and generate SIGIO signals. This exercises asynchronous I/O via SIGIO.

--sigio-ops N

stop sigio stress workers after handling N SIGIO signals.

System signals stressor

--signal N

start N workers that exercise the signal system call three different signal handlers, SIG_IGN (ignore), a SIGCHLD handler and SIG_DFL (default action). For the SIGCHLD handler, the stressor sends itself a SIGCHLD signal and checks if it has been handled. For other handlers, the stressor checks that the SIGCHLD handler has not been called. This stress test calls the signal system call directly when possible and will try to avoid the C library attempt to replace signal with the more modern sigaction system call.

--signal-ops N

stop signal stress workers after N rounds of signal handler setting.

Nested signal handling stressor

--signest N

start N workers that exercise nested signal handling. A signal is raised and inside the signal handler a different signal is raised, working through a list of signals to exercise. An alternative signal stack is used that is large enough to handle all the nested signal calls. The -v option will log the approximate size of the stack required and the average stack size per nested call.

--signest-ops N

stop after handling N nested signals.

Pending signals stressor

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

--sigpending-ops N

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

SIGPIPE stressor

--sigpipe N

start N workers that repeatedly spawn off child process that exits before a parent can complete a pipe write, causing a SIGPIPE signal. The child process is either spawned using clone(2) if it is available or use the slower fork(2) instead.

--sigpipe-ops N

stop N workers after N SIGPIPE signals have been caught and handled.

Signal queueing stressor

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

Real-time signals stressor

--sigrt N

start N workers that each create child processes to handle SIGRTMIN to SIGRMAX real time signals. The parent sends each child process a RT signal via siqueue(2) and the child process waits for this via sigwaitinfo(2). When the child receives the signal it then sends a RT signal to one of the other child processes also via sigqueue(2).

--sigrt-ops N

stop sigrt stress workers after N bogo sigqueue signal send operations.

SIGSEV stressor

--sigsegv N

start N workers that rapidly create and catch segmentation faults generated via illegal memory access, illegal vdso system calls, illegal port reads, illegal interrupts or access to x86 time stamp counter.

--sigsegv-ops N

stop sigsegv stress workers after N bogo segmentation faults.

Waiting for process signals stressor

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

SIGTRAP stressor

--sigtrap N

start N workers that exercise the SIGTRAP signal. For systems that support SIGTRAP, the signal is generated using raise(SIGTRAP). Only x86 Linux systems the SIGTRAP is also generated by an int 3 instruction.

--sigtrap-ops N

stop sigtrap stress workers after N SIGTRAP signals have been handled.

SIGURG stressor

--sigurg N

start workers that exercise the SIGURG signal by sending out-of-band data over a TCP/IP IPv4 socket stream.

--sigurg-ops N

stop sigurg stressor workers after N SIGURG signals have been handled.

SIGVTARLM stressor

--sigvtalrm N

start N workers that exercise the SIGVTALRM signal using an ITIMER_VIRTUAL itimer and a busy loop that consumes CPU time calling getitimer for the ITIMER_VIRTUAL timer.

--sigvtalrm-ops N

stop sigvtalrm stress workers after N SIGVTALRM signals have been handled.

SIGXCPU stressor

--sigxcpu N

start N workers that exercise the SIGXCPU stressor. A busy loop generates SIGXCPU signals by setting a 0 second run time limit followed by a sched_yield call.

--sigxcpu-ops N

stop sigsxcpu stress workers after N bogo SIGXCPU signal attempts.

SIGXFSZ stressor

--sigxfsz N

start N workers that exercise the SIGXFSZ stressor. A random 32 bit file size limit is set and data is written outside this size limit to generate a SIGXFSZ signal.

--sigxfsz-ops N

stop sigsxfsz stress workers after N bogo SIGXFSZ signal attempts.

Random memory and processor cache line stressor via a skiplist

--skiplist N

start N workers that store and then search for integers using a skiplist. By default, 65536 integers are added and searched. This is a useful method to exercise random access of memory and processor cache.

--skiplist-ops N

stop the skiplist worker after N skiplist store and search cycles are completed.

--skiplist-size N

specify the size (number of integers) to store and search in the skiplist. Size can be from 1 K to 4 M.

Time interrupts and context switches stressor

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

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

--sleep-ops N

stop after N sleep bogo operations.

System management interrupts (SMI) stressor

--smi N

start N workers that attempt to generate system management interrupts (SMIs) into the x86 ring -2 system management mode (SMM) by exercising the advanced power management (APM) port 0xb2. This requires the --pathological option and root privilege and is only implemented on x86 Linux platforms. This probably does not work in a virtualized environment. The stressor will attempt to determine the time stolen by SMIs with some naïve benchmarking.

--smi-ops N

stop after N attempts to trigger the SMI.

Network socket stressor

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

use network interface NAME. If the interface NAME does not exist, is not up or does not support the domain then the loopback (lo) interface is used as the default.

--sock-msgs N

send N messages per connect, send/receive, disconnect iteration. The default is 1000 messages. If N is too small then the rate is throttled back by the overhead of socket connect and disconnect (on Linux, one needs to increase /proc/sys/net/netfilter/nf_conntrack_max to allow more connections).

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

stop socket stress workers after N bogo operations.

--sock-opts [ random | 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), sendmmsg(2) or a random selection of one of these 3 on each iteration. Note that sendmmsg is only available for Linux systems that support this system call.

--sock-port P

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

--sock-protocol P

Use the specified protocol P, default is tcp. Options are tcp and mptcp (if supported by the operating system).

--sock-type [ stream | seqpacket ]

specify the socket type to use. The default type is stream. seqpacket currently only works for the unix socket domain.

--sock-zerocopy

enable zerocopy for send and recv calls if the MSG_ZEROCOPY is supported.

Socket abusing stressor

--sockabuse N

start N workers that abuse a socket file descriptor with various file based system that don’t normally act on sockets. The kernel should handle these illegal and unexpected calls gracefully.

--sockabuse-ops N

stop after N iterations of the socket abusing stressor loop.

--sockabuse-port P

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

Socket diagnostic stressor (Linux)

--sockdiag N

start N workers that exercise the Linux sock_diag netlink socket diagnostics (Linux only). This currently requests diagnostics using UDIAG_SHOW_NAME, UDIAG_SHOW_VFS, UDIAG_SHOW_PEER, UDIAG_SHOW_ICONS, UDIAG_SHOW_RQLEN and UDIAG_SHOW_MEMINFO for the AF_UNIX family of socket connections.

--sockdiag-ops N

stop after receiving N sock_diag diagnostic messages.

Socket file descriptor stressor

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

--sockfd-port P

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

--sockfd-reuse

reuse the file descriptor by passing it back from the receiver to the sender and re-sending it again rather than opening /dev/null each time.

Opening network socket stressor

--sockmany N

start N workers that use a client process to attempt to open as many as 100000 TCP/IP socket connections to a server on port 10000.

--sockmany-if NAME

use network interface NAME. If the interface NAME does not exist, is not up or does not support the domain then the loopback (lo) interface is used as the default.

--sockmany-ops N

stop after N connections.

--sockmany-port P

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

Socket I/O stressor

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

Softlockup stressor

--softlockup N

start N workers that flip between with the "real-time" SCHED_FIO and SCHED_RR scheduling policies at the highest priority to force softlockups. This can only be run with CAP_SYS_NICE capability and for best results the number of stressors should be at least the number of online CPUs. Once running, this is practically impossible to stop and it will force softlockup issues and may trigger watchdog timeout reboots.

--softlockup-ops N

stop softlockup stress workers after N bogo scheduler policy changes.

Sparse matrix stressor

--sparsematrix N

start N workers that exercise 3 different sparse matrix implementations based on hashing, Judy array (for 64 bit systems), 2-d circular linked-lists, memory mapped 2-d matrix (non-sparse), quick hashing (on preallocated nodes) and red-black tree. The sparse matrix is populated with values, random values potentially non-existing values are read, known existing values are read and known existing values are marked as zero. This default 500 × 500 sparse matrix is used and 5000 items are put into the sparse matrix making it 2% utilized.

--sparsematrix-items N

populate the sparse matrix with N items. If N is greater than the number of elements in the sparse matrix than N will be capped to create at 100% full sparse matrix.

--sparsematrix-method [ all | hash | hashjudy | judy | list | mmap
| qhash | rb ]

specify the type of sparse matrix implementation to use. The ‘all’ method uses all the methods and is the default.

--sparsematrix-ops N

stop after N sparsematrix test iterations.

--sparsematrix-size N

use a N × N sized sparse matrix

POSIX process spawn (posix_spawn) stressor (Linux)

--spawn N

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

--spawn-ops N

stop spawn stress workers after N bogo spawns.

Spinmem stressor

--spinmem N

start N workers that use a shared memory page to keep two processes synchronized using busy spin loops. One process is a writer that increments a value in memory slot 0 and spin waits for the data to appear in memory slot 1. The other process spin waits for the data to change in slot 0 and copies the changed value into memory slot 1. The stressor benchmarks the time for the transactions to occur between both processes. Note that the optimal number of stressors is half the number of online CPUs in a system. By default 32 bit write/reads are used.

--spinmem-affinity

move spinmem stressor processes to randomly selected CPUs every million spinmem transactions.

--spinmem-method [ 8bit | 16bit | 32bit | 64bit ]

select the size of the memory write/reads, the default is 32 bit.

--spinmem-numa

assign shared memory page to randomly selected NUMA nodes. This is disabled for systems that do not support NUMA.

--spinmem-ops N

stop after N spinmem bogo operations. A bogo operation is 1000 transactions betewen the two spinmem processes.

Splice stressor (Linux)

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

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

--splice-ops N

stop after N bogo splice operations.

Stack stressor

--stack N

start N workers that rapidly cause and catch stack overflows by use of large recursive stack allocations. Much like the brk stressor, this can eat up pages rapidly and may trigger the kernel OOM killer on the process, however, the killed stressor is respawned again by a monitoring parent process.

--stack-fill

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

attempt to mlock stack pages into memory causing more memory pressure by preventing pages from swapped out.

--stack-ops N

stop stack stress workers after N bogo stack overflows.

--stack-pageout

force stack pages out to swap (available when madvise(2) supports MADV_PAGEOUT).

--stack-unmap

unmap a single page in the middle of a large buffer allocated on the stack on each stack allocation. This forces the stack mapping into multiple separate allocation mappings.

Dirty page and stack exception stressor

--stackmmap N

start N workers that use a 2 MB stack that is memory mapped onto a temporary file. A recursive function works down the stack and flushes dirty stack pages back to the memory mapped file using msync(2) until the end of the stack is reached (stack overflow). This exercises dirty page and stack exception handling.

--stackmmap-ops N

stop workers after N stack overflows have occurred.

Statmount and listmount system call stressor

--statmount N

start N workers that find mounts on / via listmount and get mount information on the mount IDs using statmount. (Linux only).

--statmount-ops N

stop workers after iterating on mounts N times.

Libc string functions stressor

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

--stream N

start N workers exercising a memory bandwidth stressor very 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:

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.

The stressor calculates the memory read rate, memory write rate and floating point operations rate. These will differ from the maximum theoretical read/write/compute rates because of loop overheads and the use of volatile pointers to ensure the compiler does not optimize out stores.

--stream-index N

specify number of stream indices used to index into the data arrays a, b and c. This adds indirection into the data lookup by using randomly shuffled indexing into the three data arrays. Level 0 (no indexing) is the default, and 3 is where all 3 arrays are indexed via 3 different randomly shuffled indexes. The higher the index setting the more impact this has on L1, L2 and L3 caching and hence forces higher memory read/write latencies.

--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 4 MB.

--stream-mlock

attempt to mlock the stream buffers into memory to prevent them from being swapped out.

--stream-madvise [ collapse | hugepage | nohugepage | normal ]

Specify the madvise options used on the memory mapped buffer used in the stream stressor. Non-linux systems will only have the ‘normal’ madvise advice. The default is ‘normal’.

--stream-ops N

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

Swap partitions stressor (Linux)

--swap N

start N workers that add and remove small randomly sizes swap partitions (Linux only). Note that if too many swap partitions are added then the stressors may exit with exit code 3 (not enough resources). Requires CAP_SYS_ADMIN to run.

--swap-ops N

stop the swap workers after N swapon/swapoff iterations.

--swap-self

attempt to swap out pages of the stressor.

Context switching between mutually tied processes stressor

-s N, --switch N

start N workers that force context switching between two mutually blocking/unblocking tied processes. By default message passing over a pipe is used, but different methods are available.

--switch-freq F

run the context switching at the frequency of F context switches per second. Note that the specified switch rate may not be achieved because of CPU speed and memory bandwidth limitations.

--switch-method [ mq | pipe | sem-sysv ]

select the preferred context switch block/run synchronization method, these are as follows:

--switch-ops N

stop context switching workers after N bogo operations.

Symlink stressor

--symlink N

start N workers creating and removing symbolic links.

--symlink-ops N

stop symlink stress workers after N bogo operations.

--symlink-sync

sync dirty data and metadata to disk.

Partial file syncing (sync_file_range) stressor

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

specify the size of the file to be sync’d. One can specify the size as % of free space on the file system in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

--sync-file-ops N

stop sync-file workers after N bogo sync operations.

CPU synchronized loads stressor

--syncload N

start N workers that produce sporadic short lived loads synchronized across N stressor processes. By default repeated cycles of 125ms busy load followed by 62.5ms sleep occur across all the workers in step to create bursts of load to exercise C state transitions and CPU frequency scaling. The busy load and sleeps have +/-10% jitter added to try exercising scheduling patterns.

--syncload-msbusy M

specify the busy load duration in milliseconds.

--syncload-mssleep M

specify the sleep duration in milliseconds.

--syncload-ops N

stop syncload workers after N load/sleep cycles.

System calls bad address and fault handling stressor

--sysbadaddr N

start N workers that pass bad addresses to system calls to exercise bad address and fault handling. The addresses used are null pointers, read only pages, write only pages, unmapped addresses, text only pages, unaligned addresses and top of memory addresses.

--sysbadaddr-ops N

stop the sysbadaddr stressors after N bogo system calls.

System calls stressor

--syscall N

start N workers that exercise a range of available system calls. System calls that fail due to lack of capabilities or errors are ignored. The stressor will try to maximize the rate of system calls being executed based the entire time taken to setup, run and cleanup after each system call.

--syscall-method method

select the choice of system calls to executed based on the fastest test duration times. Note that this includes the time to setup, execute the system call and cleanup afterwards. The available methods are as follows:

--syscall-ops N

stop after N system calls

--sycsall-top N

report the fastest top N system calls. Setting N to zero will report all the system calls that could be exercised.

System information stressor

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

System calls with invalid arguments stressor (Linux)

--sysinval N

start N workers that exercise system calls in random order with permutations of invalid arguments to force kernel error handling checks. The stress test autodetects system calls that cause processes to crash or exit prematurely and will blocklist these after several repeated breakages. System call arguments that cause system calls to work successfully are also detected an blocklisted too. Linux only.

--sysinval-ops N

stop sysinval workers after N system call attempts.

/sys stressor (Linux)

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

--sysfs-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 stressor (Linux)

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

Timer event stressor (Linux)

-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-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. Note: it is also worth using --timer-slack 0 for high frequencies to stop the kernel from coalescing timer events.

--timer-ops N

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

--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 stressor (Linux)

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

--timerfs-fds N

try to use a maximum of N timerfd file descriptors per stressor.

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

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

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

Time warp stressor

--time-warp N

start N workers that read the system time and where appropriate for monotonic clocks perform a check for reverse time warping. At the end of the run there are time wrap-around checks. This stressor exercises clock_gettime(2) on all available clocks, gettimeofday(2), time(2) and getrusage(2) to check for unexpected time behaviour. Note that only some clocks are reliably monotonic.

--time-warp-ops N

stop after N rounds of checking all the available clocks and time fetching system calls.

Translation lookaside buffer shootdowns stressor

--tlb-shootdown N

start N workers that force Translation Lookaside Buffer (TLB) shootdowns. This is achieved by creating up to 16 child processes that all share a region of memory and these processes are shared amongst the available CPUs. The processes adjust the page mapping settings causing TLBs to be force flushed on the other processors, causing the TLB shootdowns.

--tlb-shootdown-ops N

stop after N bogo TLB shootdown operations are completed.

Tmpfs stressor

--tmpfs N

start N workers that create a temporary file on an available tmpfs file system and perform various file based mmap operations upon it.

--tmpfs-mmap-async

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

--tmpfs-mmap-file

enable tmpfs file based memory mapping and by default use synchronous msync’ing on each page.

--tmpfs-ops N

stop tmpfs stressors after N bogo mmap operations.

Touching files stressor

--touch N

touch files by using open(2) or creat(2) and then closing and unlinking them. The filename contains the bogo-op number and is incremented on each touch operation, hence this fills the dentry cache. Note that the user time and system time may be very low as most of the run time is waiting for file I/O and this produces very large bogo-op rates for the very low CPU time used.

--touch-method [ random | open | creat ]

select the method the file is created, either randomly using open(2) or create(2), just using open(2) with the O_CREAT open flag, or with creat(2).

--touch-ops N

stop the touch workers after N file touches.

--touch-opts all, direct, dsync, excl, noatime, sync

specify various file open options as a comma separated list. Options are as follows:

Tree data structures stressor

--tree N

start N workers that exercise tree data structures. The default is to add, find and remove 250,000 64 bit integers into AVL (avl), Red-Black (rb), Splay (splay), btree and binary trees. The intention of this stressor is to exercise memory and cache with the various tree operations.

--tree-method [ all | avl | binary | btree | rb | splay ]

specify the tree to be used. By default, all the trees are used (the ‘all’ option).

--tree-ops N

stop tree stressors after N bogo ops. A bogo op covers the addition, finding and removing all the items into the tree(s).

--tree-size N

specify the size of the tree, where N is the number of 64 bit integers to be added into the tree.

Trigonometric functions stressor

--trig N

start N workers that exercise sin, cos, sincos (where available) and tan trigonometric functions using float, double and long double floating point variants. Each function is exercised 10,000 times per bogo-operation.

--trig-method function

specify a trigonometric stress function. By default, all the functions are exercised sequentially, however one can specify just one function to be used if required. Available options are as follows:

--trig-ops N

stop after N bogo-operations.

Time stamp counter (TSC) stressor

--tsc N

start N workers that read the Time Stamp Counter (TSC) 256 times per loop iteration (bogo operation). This exercises the tsc instruction for x86, the mftb instruction for ppc64, the rdcycle instruction for RISC-V, the tick instruction on SPARC and the rdtime.d instruction for Loong64.

--tsc-lfence

add lfence after each tsc read to force serialization (x86 only).

--tsc-ops N

stop the tsc workers after N bogo operations are completed.

--tsc-rdtscp

use the rdtscp instruction instead of rdtsc (x86 only). This also disables the --tsc-lfence option.

Binary tree stressor

--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 1 K to 4 M.

Network tunnel stressor

--tun N

start N workers that create a network tunnel device and sends and receives packets over the tunnel using UDP and then destroys it. A new random 192.168.*.* IPv4 address is used each time a tunnel is created.

--tun-ops N

stop after N iterations of creating/sending/receiving/destroying a tunnel.

--tun-tap

use network tap device using level 2 frames (bridging) rather than a tun device for level 3 raw packets (tunnelling).

UDP network stressor

--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 and ipv6 are supported.

--udp-gro

enable UDP-GRO (Generic Receive Offload) if supported.

--udp-if NAME

use network interface NAME. If the interface NAME does not exist, is not up or does not support the domain then the loopback (lo) interface is used as the default.

--udp-lite

use the UDP-Lite (RFC 3828) protocol (only for ipv4 and ipv6 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 flooding stressor

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

use network interface NAME. If the interface NAME does not exist, is not up or does not support the domain then the loopback (lo) interface is used as the default.

--udp-flood-ops N

stop udp-flood stress workers after N bogo operations.

File umask stressor

--umask N

start N workers that exercise setting umask and creating/fstat’ing/closing/unlinking a file and checking the file mode is set correctly. This exercises umask mask values from octal 0000 to 0777 inclusive.

--umask-ops N

stop after N rounds of exercising umask values 0000 to 0777.

Umount stressor

--umount N

start N workers that exercise mounting and racying unmounting of small tmpfs and ramfs file systems. Three child processes are invoked, one to mount, another to force umount and a third to exercise /proc/mounts. Small random delays are used between mount and umount calls to try to trigger race conditions on the umount calls.

--umount-ops N

stop umount workers after N successful bogo mount/umount operations.

Unlink stressor

--unlink N

start N workers that each run 4 processes per worker that create, open, unlink and close 1024 files in randomized order to exercise unlinking (removal) of files. This attempts to create races on file creation, linking and unlinking.

--unlink-ops N

stop after N bogo rounds of unlink operations on 1024 files by the controlling worker.

Unshare stressor (Linux)

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

Uprobe stressor (Linux)

--uprobe N

start N workers that trace the entry to libc function getpid() using the Linux uprobe kernel tracing mechanism. This requires CAP_SYS_ADMIN capabilities and a modern Linux uprobe capable kernel.

--uprobe-ops N

stop uprobe tracing after N trace events of the function that is being traced.

/dev/urandom stressor (Linux)

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

Page faults stressor (Linux)

--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 quantity of major page faults and also context switches during the handling of the page faults. (Linux only).

--userfaultfd-bytes N

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

--userfaultfd-ops N

stop userfaultfd stress workers after N page faults.

SYGSYS stressor

--usersyscall N

start N workers that exercise the Linux prctl userspace system call mechanism. A userspace system call is handled by a SIGSYS signal handler and exercised with the system call disabled (ENOSYS) and enabled (via SIGSYS) using prctl PR_SET_SYSCALL_USER_DISPATCH.

--usersyscall-ops N

stop after N successful userspace syscalls via a SIGSYS signal handler.

File timestamp stressor

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

--utime-ops N

stop utime stress workers after N utime bogo operations.

Virtual dynamic shared object stressor

--vdso N

start N workers that repeatedly call each of the system call functions in the vDSO (virtual dynamic shared object). The vDSO is a shared library that the kernel maps into the address space of all user-space applications to allow fast access to kernel data to some system calls without the need of performing an expensive system call.

--vdso-func F

Instead of calling all the vDSO functions, just call the vDSO function F. The functions depend on the kernel being used, but are typically clock_gettime, getcpu, gettimeofday and time.

--vdso-ops N

stop after N vDSO functions calls.

Vector integer comparison operations stressor

--veccmp N

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

--veccmp-ops N

stop after N bogo vector integer comparison operations.

Vector floating point operations stressor

--vecfp N

start N workers that exericise floating point (single and double precision) addition, multiplication, division and negation on vectors of 128, 64, 32, 16 and 8 floating point values. The -v option will show the approximate throughput in millions of floating pointer operations per second for each operation. For x86, the gcc/clang target clones attribute has been used to produced vector optimizations for a range of mmx, sse, avx and processor features.

--vecfp-method method

specify a vecfp stress method. By default, all the stress methods are exercised sequentially, however one can specify just one method to be used if required.

--vecfp-ops N

stop after N vector floating point bogo-operations. Each bogo-op is equivalent to 65536 loops of 2 vector operations. For example, one bogo-op on a 16 wide vector is equivalent to 65536 × 2 × 16 floating point operations.

Vector math operations stressor

--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 and where supported 1 × 128 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.

Shuffled vector math operations stressor

--vecshuf N

start N workers that shuffle data on various 64 byte vectors comprised of 8, 16, 32, 64 and 128 bit unsigned integers. The integers are shuffled around the vector with 4 shuffle operations per loop, 65536 loops make up one bogo-op of shuffling. The data shuffling rates and shuffle operation rates are logged when using the -v option. This stressor exercises vector load, shuffle/permute, packing/unpacking and store operations.

--vecshuf-method method

specify a vector shuffling stress method. By default, all the stress methods are exercised sequentially, however one can specify just one method to be used if required.

--vecshuf-ops N

stop after N bogo vector shuffle ops. One bogo-op is equavlent of 4 × 65536 vector shuffle operations on 64 bytes of vector data.

Wide vector math operations stressor

--vecwide N

start N workers that perform various 8 bit math operations on vectors of 4, 8, 16, 32, 64, 128, 256, 512, 1024 and 2048 bytes. With the -v option the relative compute performance vs the expected compute performance based on total run time is shown for the first vecwide worker. The vecwide stressor exercises various processor vector instruction mixes and how well the compiler can map the vector operations to the target instruction set.

--vecwide-ops N

stop after N bogo vector operations (2048 iterations of a mix of vector instruction operations).

File based authenticy protection (verity) stressor

--verity N

start N workers that exercise read-only file based authenticy protection using the verity ioctls FS_IOC_ENABLE_VERITY and FS_IOC_MEASURE_VERITY. This requires file systems with verity support (currently ext4 and f2fs on Linux) with the verity feature enabled. The test attempts to creates a small file with multiple small extents and enables verity on the file and verifies it. It also checks to see if the file has verity enabled with the FS_VERITY_FL bit set on the file flags.

--verity-ops N

stop the verity workers after N file create, enable verity, check verity and unlink cycles.

vfork stressor

--vfork N

start N workers continually vforking children that immediately exit.

--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 process table using high values for --vfork-max and --vfork.

--vfork-ops N

stop vfork stress workers after N bogo operations.

vfork processes as much as possible stressor

--vforkmany N

start N workers that spawn off a chain of vfork children until the process table fills up and/or vfork fails. vfork can rapidly create child processes and the parent process has to wait until the child dies, so this stressor rapidly fills up the process table.

--vforkmany-ops N

stop vforkmany stressors after N vforks have been made.

--vforkmany-vm

enable detrimental performance virtual memory advice using madvise on all pages of the vforked process. Where possible this will try to set every page in the new process with using madvise MADV_MERGEABLE, MADV_WILLNEED, MADV_HUGEPAGE and MADV_RANDOM flags. Linux only.

--vforkmany-vm-bytes N

mmap N bytes per vm worker for more memory pressure, the default is 64 MB. This also enables the --vforkmany-vm option. One can specify the size as % of total available memory or in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

Memory allocate and write stressor

-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 in total, this is shared by each vm worker, the default is 256 MB. One can specify the size as % of total available memory or in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

--vm-flush

cache flush mapped memory after each memory region has been completely written to.

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

Specify the madvise ‘advice’ option used on the memory mapped regions used in the vm stressor. Non-linux systems will only have the ‘normal’ madvise advice, linux systems support ‘collapse’, ‘dontneed’, ‘hugepage’, ‘mergeable’ , ‘nohugepage’, ‘normal’, ‘random’, ‘sequential’, ‘unmergeable’ and ‘willneed’ advice. If this option is not used then the default is to pick random madvise advice for each mmap call. See madvise(2) for more details.

--vm-method method

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:

--vm-numa

assign memory mapped pages to randomly selected NUMA nodes. This is disabled for systems that do not support NUMA.

--vm-ops N

stop vm workers after N bogo operations.

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

Virtual memory addressing stressor

--vm-addr N

start N workers that exercise virtual memory addressing using various methods to walk through a memory mapped address range. This will exercise mapped private addresses from 8 MB to 64 MB per worker and try to generate cache and TLB inefficient addressing patterns. Each method will set the memory to a random pattern in a write phase and then sanity check this in a read phase.

--vm-addr-method method

specify a vm address stress method. By default, all the stress methods are exercised sequentially, however one can specify just one method to be used if required.

Available vm address stress methods are described as follows:

--vm-addr-mlock

attempt to mlock pages into memory causing more memory pressure by preventing pages from swapped out.

--vm-addr-numa

assign memory mapped pages to randomly selected NUMA nodes. This is disabled for systems that do not support NUMA.

--vm-addr-ops N

stop N workers after N bogo addressing passes.

Memory transfer between parent and child processes stressor (Linux)

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

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

--vm-rw-ops N

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

Memory unmap from a child process stressor

--vm-segv N

start N workers that create a child process that unmaps its address space causing a SIGSEGV on return from the unmap.

--vm-segv-ops N

stop after N bogo vm-segv SIGSEGV faults.

Vmsplice stressor (Linux)

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

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

--vm-splice-ops N

stop after N bogo vm-splice operations.

Virtual Memory Area (VMA) stressor

--vma N

start M workers that create pthreads to mmap, munmap, mlock, munlock, madvise, msync, mprotect, mincore and access 32 pages in a randomly selected virtual memory address space. This is designed to trip races on VMA page modifications. Every 15 seconds a different virtual address space is randomly chosen.

--vma-ops N

stop the vma stressors after N successful memory mappings.

Vector neural network instructions stressor

--vnni N

start N workers that exercise vector neural network instructions (VNNI) used in convolutional neural network loops. A 256 byte vector is operated upon using 8 bit multiply with 16 bit summation, 16 bit multiply and 32 bit summation, and 8 bit summation. When processor features allow, these operations using 512, 256 and 128 bit vector operations. Generic non-vectorized code variants also provided (which may be vectorized by more advanced optimising compilers).

--vnni-intrinsic

just use the vnni methods that use intrinsic VNNI instructions and ignore the generic non-vectorized methods.

--vnni-method N

select the VNNI method to be exercised, may be one of:

--vnni-ops N

stop after N bogo VNNI computation operations. 1 bogo-op is equivalent to 1024 convolution loops operating on 256 bytes of data.

Pausing and resuming threads stressor

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

CPU wait instruction stressor

--waitcpu N

start N workers that exercise processor wait instructions. For x86 these are pause, tpause and umwait (when available) and nop. For ARM the yield instruction is used. For PPC64 the yield, mdoio and mdooom instructions are used. For RISC-V the pause instruction is used. For Loong64 the dbar instruction is used. For other architectures no-op instructions are used.

--waitcpu-ops N

stop after N bogo processor wait operations.

Watchdog stressor

--watchdog N

start N workers that exercising the /dev/watchdog watchdog interface by opening it, perform various watchdog specific ioctl(2) commands on the device and close it. Before closing the special watchdog magic close message is written to the device to try and force it to never trip a watchdog reboot after the stressor has been run. Note that this stressor needs to be run as root with the --pathological option and is only available on Linux.

--watchdog-ops N

stop after N bogo operations on the watchdog device.

Libc wide characterstring function stressor

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

scheduler workload stressor

--workload N

start N workers that exercise the scheduler with items of work that are started at random times with random sleep delays between work items. By default a 100,000 microsecond slice of time has 100 work items that start at random times during the slice. The work items by default run for a quanta of 1000 microseconds scaled by the percentage work load (default of 30%). For a slice of S microseconds and a work item quanta duration of Q microseconds, S / Q work items are executed per slice. For a work load of L percent, the run time per item is the quanta Q × L / 100 microseconds. The --workload-threads option allows work items to be taken from a queue and run concurrently if the scheduling run times overlap.
If a work item is already running when a new work item is scheduled to run then the new work item is delayed and starts directly after the completion of the currently running work item when running with the default of zero worker threads. This emulates bursty scheduled compute, such as handling input packets where one may have lots of work items bunched together or with random unpredictable delays between work items.

--workload-load L

specify the percentage run time load of each work item with respect to the run quanta duration. Essentially the run duration of each work item is the quanta duration Q × L / 100.

--workload-method method

select the workload method. Each quanta of execution time is consumed using a tight spin-loop executing a workload method. The available methods are described as follows:

--workload-sched [ batch | deadline | fifo | idle | other | rr ]

select scheduling policy. Note that deadline, fifo and rr require root privilege.

--workload-slice-us S

specify the duration of each scheduling slice in microseconds. The default is 100,000 microseconds (0.1 seconds).

--workload-quanta-us Q

specify the duration of each work item in microseconds. The default is 1000 microseconds (1 millisecond).

--workload-threads N

use N process threads to take scheduler work items of a workqueue and run the work item (default is 2). When N is 0, no threads are used and the work items are run back-to-back sequentially without using work queue. Using more than 2 threads allows work items to be handled concurrently if enough idle processors are available.

--workload-dist [ cluster | even | poisson | random1 | random2 |
random3 ]

specify the scheduling distribution of work items, the default is cluster. The distribution methods are described as follows:

--workload-ops N

stop the workload workers after N workload bogo-operations.

x86 cpuid stressor

--x86cpuid N

start N workers that exercise the x86 cpuid instruction with 18 different leaf types.

--x86cpuid-ops N

stop after N iterations that exercise the different cpuid leaf types.

x86-64 syscall stressor (Linux)

--x86syscall N

start N workers that repeatedly exercise the x86-64 syscall instruction to call the getcpu(2), geteuid(2), getgid(2), getpid(2), gettimeofday(2) and time(2) system calls using the Linux vsyscall handler. Only for Linux.

--x86syscall-func F

Instead of exercising the 6 syscall system calls, just call the syscall function F. The function F must be one of getcpu, geteuid, getgid, getpid, gettimeofday or time.

--x86syscall-ops N

stop after N x86syscall system calls.

Extended file attributes stressor

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

Yield scheduling stressor

-y N, --yield N

start N workers that call sched_yield(2). This stressor ensures that at least 2 child processes per CPU exercise 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.

--yield-procs N

specify the number of child processes to run per stressor instance. The default is 2, range 1 to 65536.

--yield-sched [ batch | deadline | fifo | idle | other | rr ]

select scheduling policy. Note that deadline, fifo and rr require root privilege.

/dev/zero stressor

--zero N

start N workers that exercise /dev/zero with reads, lseeks, ioctls and mmaps. For just /dev/zero read benchmarking use the --zero-read option.

--zero-ops N

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

--zero-read

just read /dev/zero with 4 K reads with no additional exercising on /dev/zero.

Zlib stressor

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

specify the compression level (0..9), where 0 = no compression, 1 = fastest compression and 9 = best compression.

--zlib-mem-level L

specify the reserved compression state memory for zlib. Default is 8.

--zlib-method method

specify the type of random data to send to the zlib library. By default, the data stream is created from a random selection of the different data generation processes. However one can specify just one method to be used if required. Available zlib data generation methods are described as follows:

--zlib-ops N

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

--zlib-strategy S

specifies the strategy to use when deflating data. This is used to tune the compression algorithm. Default is 0.

--zlib-stream-bytes S

specify the amount of bytes to deflate until deflate should finish the block and return with Z_STREAM_END. One can specify the size in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g. Default is 0 which creates and endless stream until stressor ends.

--zlib-window-bits W

specify the window bits used to specify the history buffer size. The value is specified as the base two logarithm of the buffer size (e.g. value 9 is 2↑9 = 512 bytes). Default is 15.

Zombie processes stressor

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

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

--zombie-ops N

stop zombie stress workers after N bogo zombie operations.

EXAMPLES

stress-ng --vm 8 --vm-bytes 80% -t 1h

run 8 virtual memory stressors that combined use 80% of the available memory for 1 hour. Thus each stressor uses 10% of the available memory.

stress-ng --vm 50% -t 1h

run virtual memory stressors on 50% of the number of online cpus for 1 hour.

stress-ng --vm 200% -t 1h

run virtual memory stressors on 2 times the number of online cpus for 1 hour.

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 1 GB of virtual memory.

stress-ng --iomix 2 --iomix-bytes 10% -t 10m

runs 2 instances of the mixed I/O stressors using a total of 10% of the available file system space for 10 minutes. Each stressor will use 5% of the available file system space.

stress-ng --with cpu,matrix,vecmath,fp --seq 8 -t 1m

run 8 instances of cpu, matrix, vecmath and fp stressors sequentially one after another, for 1 minute per stressor.

stress-ng --with cpu,matrix,vecmath,fp --permute 5 -t 10s

run permutations of 5 instances of cpu, matrix, vecmath and fp stressors sequentially one after another, for 10 seconds per permutation mix.

stress-ng --cyclic 1 --cyclic-dist 2500 --cyclic-method clock_ns --cyclic-prio 100 --cyclic-sleep 10000 --hdd 0 -t 1m

measures real time scheduling latencies created by the hdd stressor. This uses the high resolution nanosecond clock to measure latencies during sleeps of 10,000 nanoseconds. At the end of 1 minute of stressing, the latency distribution with 2500 ns intervals will be displayed. NOTE: this must be run with the CAP_SYS_NICE capability to enable the real time scheduling to get accurate measurements.

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 -1 --cpu-method all -t 1h --cpu-load 90

run cpu stressors on all online CPUs working through all the available CPU stressors for 1 hour, loading the CPUs at 90% load capacity.

stress-ng --cpu 0 --cpu-method all -t 20m

run cpu stressors on all configured CPUs working through all the available CPU stressors for 20 minutes

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 -1 -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 --class io\?

show all the stressors in the io class

stress-ng --all -1 --maximize --aggressive

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

stress-ng --all 8 --with cpu,hash,nop,vm --timeout 1m

run 8 instances of cpu, hash, nop and vm stressors altogether for 1 minute.

stress-ng --seq 8 --with cpu,hash,nop,vm --timeout 1m --progress

run 8 instances of cpu, hash, nop and vm stressors one after another for 1 minute each and show the run progress.

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 another, excluding the bigheap, brk and stack stressors

stress-ng --taskset 0,2-3 --cpu 3

run 3 instances of the CPU stressor and pin them to CPUs 0, 2 and 3.

stress-ng --taskset odd --cpu 32

run 32 instances of the CPU stressor and pin them to odd numbered CPUs.

EXIT STATUS