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.
The tool has a wide range of different stress mechanisms (known as “stressors”) and a full description of these is included in the man page. This document is a quick-start reference guide and covers some of the more typical use cases for stress-ng.
sudo apt install stress-ng
brew install stress-ng
stress-ng [OPTION [ARG]]
General control options:
--abort abort all stressors if any stressor fails
--aggressive enable all aggressive options
-a N, --all N start N workers of each stress test
-b N, --backoff N wait of N microseconds before work starts
--class name specify a class of stressors, use with --sequential
-n, --dry-run do not run
--ftrace enable kernel function call tracing
-h, --help show help
--ignite-cpu alter kernel controls to make CPU run hot
--ionice-class C specify ionice class (idle, besteffort, realtime)
--ionice-level L specify ionice level (0 max, 7 min)
-j, --job jobfile run the named jobfile
-k, --keep-name keep stress worker names to be 'stress-ng'
--keep-files do not remove files or directories
--klog-check check kernel message log for errors
--log-brief less verbose log messages
--log-file filename log messages to a log file
--maximize enable maximum stress options
--max-fd set maximum file descriptor limit
-M, --metrics print pseudo metrics of activity
--metrics-brief enable metrics and only show non-zero results
--minimize enable minimal stress options
--no-madvise don't use random madvise options for each mmap
--no-rand-seed seed random numbers with the same constant
--oomable Do not respawn a stressor if it gets OOM'd
--page-in touch allocated pages that are not in core
--parallel N synonym for 'all N'
--pathological enable stressors that are known to hang a machine
-q, --quiet quiet output
-r, --random N start N random workers
--sched type set scheduler type
--sched-prio N set scheduler priority level N
--sched-period N set period for SCHED_DEADLINE to N nanosecs (Linux only)
--sched-runtime N set runtime for SCHED_DEADLINE to N nanosecs (Linux only)
--sched-deadline N set deadline for SCHED_DEADLINE to N nanosecs (Linux only)
--sched-reclaim set reclaim cpu bandwidth for deadline scheduler (Linux only)
--seed N set the random number generator seed with a 64 bit value
--sequential N run all stressors one by one, invoking N of them
--skip-silent silently skip unimplemented stressors
--stressors show available stress tests
--smart show changes in S.M.A.R.T. data
--syslog log messages to the syslog
--taskset use specific CPUs (set CPU affinity)
--temp-path path specify path for temporary directories and files
--thrash force all pages in causing swap thrashing
-t N, --timeout T timeout after T seconds
--timer-slack enable timer slack mode
--times show run time summary at end of the run
--timestamp timestamp log output
--tz collect temperatures from thermal zones (Linux only)
-v, --verbose verbose output
--verify verify results (not available on all tests)
--verifiable show stressors that enable verification via --verify
-V, --version show version
-Y, --yaml file output results to YAML formatted file
-x, --exclude list of stressors to exclude (not run)
Stressor specific options:
--access N start N workers that stress file access permissions
--access-ops N stop after N file access bogo operations
--af-alg N start N workers that stress AF_ALG socket domain
--af-alg-ops N stop after N af-alg bogo operations
--af-alg-dump dump internal list from /proc/crypto to stdout
--affinity N start N workers that rapidly change CPU affinity
--affinity-ops N stop after N affinity bogo operations
--affinity-rand change affinity randomly rather than sequentially
--affinity-delay delay in nanoseconds between affinity changes
--affinity-pin keep per stressor threads pinned to same CPU
--affinity-sleep sleep in nanoseconds between affinity changes
--aio N start N workers that issue async I/O requests
--aio-ops N stop after N bogo async I/O requests
--aio-requests N number of async I/O requests per worker
--aiol N start N workers that exercise Linux async I/O
--aiol-ops N stop after N bogo Linux aio async I/O requests
--aiol-requests N number of Linux aio async I/O requests per worker
--apparmor start N workers exercising AppArmor interfaces
--apparmor-ops N stop after N bogo AppArmor worker bogo operations
--alarm N start N workers exercising alarm timers
--alarm-ops N stop after N alarm bogo operations
--atomic start N workers exercising GCC atomic operations
--atomic-ops stop after N bogo atomic bogo operations
--bad-altstack N start N workers exercising bad signal stacks
--bad-altstack-ops N stop after N bogo signal stack SIGSEGVs
--bad-ioctl N start N stressors that perform illegal read ioctls on devices
--bad-ioctl-ops N stop after N bad ioctl bogo operations
-B N, --bigheap N start N workers that grow the heap using calloc()
--bigheap-ops N stop after N bogo bigheap operations
--bigheap-growth N grow heap by N bytes per iteration
--bind-mount N start N workers exercising bind mounts
--bind-mount-ops N stop after N bogo bind mount operations
--binderfs N start N workers exercising binderfs
--binderfs-ops N stop after N bogo binderfs operations
--branch N start N workers that force branch misprediction
--branch-ops N stop after N branch misprediction branches
--brk N start N workers performing rapid brk calls
--brk-ops N stop after N brk bogo operations
--brk-mlock attempt to mlock newly mapped brk pages
--brk-notouch don't touch (page in) new data segment page
--bsearch N start N workers that exercise a binary search
--bsearch-ops N stop after N binary search bogo operations
--bsearch-size N number of 32 bit integers to bsearch
-C N, --cache N start N CPU cache thrashing workers
--cache-ops N stop after N cache bogo operations
--cache-enable-all enable all cache options (fence,flush,sfence,etc..)
--cache-fence serialize stores
--cache-level N only exercise specified cache
--cache-no-affinity do not change CPU affinity
--cache-prefetch prefetch on memory reads/writes
--cache-ways N only fill specified number of cache ways
--cache-wb cache line writeback (x86 only)
--cap N start N workers exercising capget
--cap-ops N stop cap workers after N bogo capget operations
--chattr N start N workers thrashing chattr file mode bits
--chattr-ops N stop chattr workers after N bogo operations
--chdir N start N workers thrashing chdir on many paths
--chdir-ops N stop chdir workers after N bogo chdir operations
--chdir-dirs N select number of directories to exercise chdir on
--chmod N start N workers thrashing chmod file mode bits
--chmod-ops N stop chmod workers after N bogo operations
--chown N start N workers thrashing chown file ownership
--chown-ops N stop chown workers after N bogo operations
--chroot N start N workers thrashing chroot
--chroot-ops N stop chroot workers after N bogo operations
--clock N start N workers thrashing clocks and POSIX timers
--clock-ops N stop clock workers after N bogo operations
--clone N start N workers that rapidly create and reap clones
--clone-ops N stop after N bogo clone operations
--clone-max N set upper limit of N clones per worker
--close N start N workers that exercise races on close
--close-ops N stop after N bogo close operations
--context N start N workers exercising user context
--context-ops N stop context workers after N bogo operations
--copy-file N start N workers that copy file data
--copy-file-ops N stop after N copy bogo operations
--copy-file-bytes N specify size of file to be copied
-c N, --cpu N start N workers that perform CPU only loading
--cpu-ops N stop after N cpu bogo operations
-l P, --cpu-load P load CPU by P %, 0=sleep, 100=full load (see -c)
--cpu-load-slice S specify time slice during busy load
--cpu-method M specify stress cpu method M, default is all
--cpu-old-metrics use old CPU metrics instead of normalized metrics
--cpu-online N start N workers offlining/onlining the CPUs
--cpu-online-ops N stop after N offline/online operations
--crypt N start N workers performing password encryption
--crypt-ops N stop after N bogo crypt operations
--cyclic N start N cyclic real time benchmark stressors
--cyclic-ops N stop after N cyclic timing cycles
--cyclic-method M specify cyclic method M, default is clock_ns
--cyclic-dist N calculate distribution of interval N nanosecs
--cyclic-policy P used rr or fifo scheduling policy
--cyclic-prio N real time scheduling priority 1..100
--cyclic-sleep N sleep time of real time timer in nanosecs
--daemon N start N workers creating multiple daemons
--daemon-ops N stop when N daemons have been created
--dccp N start N workers exercising network DCCP I/O
--dccp-domain D specify DCCP domain, default is ipv4
--dccp-if I use network interface I, e.g. lo, eth0, etc.
--dccp-ops N stop after N DCCP bogo operations
--dccp-opts option DCCP data send options [send|sendmsg|sendmmsg]
--dccp-port P use DCCP ports P to P + number of workers - 1
--dekker N start N workers that exercise ther Dekker algorithm
--dekker-ops N stop after N dekker mutex bogo operations
-D N, --dentry N start N dentry thrashing stressors
--dentry-ops N stop after N dentry bogo operations
--dentry-order O specify unlink order (reverse, forward, stride)
--dentries N create N dentries per iteration
--dev N start N device entry thrashing stressors
--dev-ops N stop after N device thrashing bogo ops
--dev-file name specify the /dev/ file to exercise
--dev-shm N start N /dev/shm file and mmap stressors
--dev-shm-ops N stop after N /dev/shm bogo ops
--dir N start N directory thrashing stressors
--dir-ops N stop after N directory bogo operations
--dir-dirs N select number of directories to exercise dir on
--dirdeep N start N directory depth stressors
--dirdeep-ops N stop after N directory depth bogo operations
--dirdeep-bytes N size of files to create per level (see --dirdeep-files)
--dirdeep-dirs N create N directories per level
--dirdeep-files N create N files per level (see --dirdeep-bytes)
--dirdeep-inodes N create a maximum N inodes (N can also be %)
--dirmany N start N directory file populating stressors
--dirmany-ops N stop after N directory file bogo operations
--dirmany-filsize specify size of files (default 0
--dnotify N start N workers exercising dnotify events
--dnotify-ops N stop dnotify workers after N bogo operations
--dup N start N workers exercising dup/close
--dup-ops N stop after N dup/close bogo operations
--dynlib N start N workers exercising dlopen/dlclose
--dynlib-ops N stop after N dlopen/dlclose bogo operations
--efivar N start N workers that read EFI variables
--efivar-ops N stop after N EFI variable bogo read operations
--enosys N start N workers that call non-existent system calls
--enosys-ops N stop after N enosys bogo operations
--env N start N workers setting environment vars
--env-ops N stop after N env bogo operations
--epoll N start N workers doing epoll handled socket activity
--epoll-ops N stop after N epoll bogo operations
--epoll-port P use socket ports P upwards
--epoll-domain D specify socket domain, default is unix
--eventfd N start N workers stressing eventfd read/writes
--eventfd-ops N stop eventfd workers after N bogo operations
--eventfs-nonblock poll with non-blocking I/O on eventfd fd
--exec N start N workers spinning on fork() and exec()
--exec-ops N stop after N exec bogo operations
--exec-max P create P workers per iteration, default is 1
--exit-group N start N workers that exercise exit_group
--exit-group-ops N stop exit_group workers after N bogo exit_group loops
--fallocate N start N workers fallocating 16MB files
--fallocate-ops N stop after N fallocate bogo operations
--fallocate-bytes N specify size of file to allocate
--fanotify N start N workers exercising fanotify events
--fanotify-ops N stop fanotify workers after N bogo operations
--fault N start N workers producing page faults
--fault-ops N stop after N page fault bogo operations
--fcntl N start N workers exercising fcntl commands
--fcntl-ops N stop after N fcntl bogo operations
--fiemap N start N workers exercising the FIEMAP ioctl
--fiemap-ops N stop after N FIEMAP ioctl bogo operations
--fiemap-bytes N specify size of file to fiemap
--fifo N start N workers exercising fifo I/O
--fifo-ops N stop after N fifo bogo operations
--fifo-readers N number of fifo reader stressors to start
--file-ioctl N start N workers exercising file specific ioctls
--file-ioctl-ops N stop after N file ioctl bogo operations
--filename N start N workers exercising filenames
--filename-ops N stop after N filename bogo operations
--filename-opts opt specify allowed filename options
--flock N start N workers locking a single file
--flock-ops N stop after N flock bogo operations
-f N, --fork N start N workers spinning on fork() and exit()
--fork-ops N stop after N fork bogo operations
--fork-max P create P workers per iteration, default is 1
--fork-vm enable extra virtual memory pressure
--fp-error N start N workers exercising floating point errors
--fp-error-ops N stop after N fp-error bogo operations
--fpunch N start N workers punching holes in a 16MB file
--fpunch-ops N stop after N punch bogo operations
--fstat N start N workers exercising fstat on files
--fstat-ops N stop after N fstat bogo operations
--fstat-dir path fstat files in the specified directory
--full N start N workers exercising /dev/full
--full-ops N stop after N /dev/full bogo I/O operations
--funccall N start N workers exercising 1 to 9 arg functions
--funccall-ops N stop after N function call bogo operations
--funccall-method M select function call method M
--funcret N start N workers exercising function return copying
--funcret-ops N stop after N function return bogo operations
--funcret-method M select method of exercising a function return type
--futex N start N workers exercising a fast mutex
--futex-ops N stop after N fast mutex bogo operations
--get N start N workers exercising the get*() system calls
--get-ops N stop after N get bogo operations
--getdent N start N workers reading directories using getdents
--getdent-ops N stop after N getdents bogo operations
--getrandom N start N workers fetching random data via getrandom()
--getrandom-ops N stop after N getrandom bogo operations
--goto N start N workers that exercise heavy branching
--goto-ops N stop after 1024 x N goto bogo operations
--goto-direction D select goto direction forward, backward, random
--gpu N start N GPU worker
--gpu-ops N stop after N gpu render bogo operations
--gpu-frag N specify shader core usage per pixel
--gpu-tex-size N specify upload texture NxN
--gpu-upload N specify upload texture N times per frame
--gpu-xsize X specify framebuffer size x
--gpu-ysize Y specify framebuffer size y
--handle N start N workers exercising name_to_handle_at
--handle-ops N stop after N handle bogo operations
--hash N start N workers that exercise various hash functions
--hash-ops N stop after N hash bogo operations
--hash-method M specify stress hash method M, default is all
-d N, --hdd N start N workers spinning on write()/unlink()
--hdd-ops N stop after N hdd bogo operations
--hdd-bytes N write N bytes per hdd worker (default is 1GB)
--hdd-opts list specify list of various stressor options
--hdd-write-size N set the default write size to N bytes
--heapsort N start N workers heap sorting 32 bit random integers
--heapsort-ops N stop after N heap sort bogo operations
--heapsort-size N number of 32 bit integers to sort
--hrtimers N start N workers that exercise high resolution timers
--hrtimers-ops N stop after N bogo high-res timer bogo operations
--hrtimers-adjust adjust rate to try and maximum timer rate
--hsearch N start N workers that exercise a hash table search
--hsearch-ops N stop after N hash search bogo operations
--hsearch-size N number of integers to insert into hash table
--icache N start N CPU instruction cache thrashing workers
--icache-ops N stop after N icache bogo operations
--icmp-flood N start N ICMP packet flood workers
--icmp-flood-ops N stop after N ICMP bogo operations (ICMP packets)
--idle-page N start N idle page scanning workers
--idle-page-ops N stop after N idle page scan bogo operations
--inode-flags N start N workers exercising various inode flags
--inode-flags-ops N stop inode-flags workers after N bogo operations
--inotify N start N workers exercising inotify events
--inotify-ops N stop inotify workers after N bogo operations
-i N, --io N start N workers spinning on sync()
--io-ops N stop sync I/O after N io bogo operations
--iomix N start N workers that have a mix of I/O operations
--iomix-bytes N write N bytes per iomix worker (default is 1GB)
--iomix-ops N stop iomix workers after N iomix bogo operations
--ioport N start N workers exercising port I/O
--ioport-ops N stop ioport workers after N port bogo operations
--ioprio N start N workers exercising set/get iopriority
--ioprio-ops N stop after N io bogo iopriority operations
--io-uring N start N workers that issue io-uring I/O requests
--io-uring-ops N stop after N bogo io-uring I/O requests
--ipsec-mb N start N workers exercising the IPSec MB encoding
--ipsec-mb-ops N stop after N ipsec bogo encoding operations
--ipsec-mb-feature F specify CPU feature F
--itimer N start N workers exercising interval timers
--itimer-ops N stop after N interval timer bogo operations
--itimer-rand enable random interval timer frequency
--jpeg N start N workers that burn cycles with no-ops
--jpeg-ops N stop after N jpeg bogo no-op operations
--jpeg-height N image height in pixels
--jpeg-image type image type: one of brown, flat, gradient, noise, plasma or xstripes
--jpeg-width N image width in pixels
--jpeg-quality Q compression quality 1 (low) .. 100 (high)
--judy N start N workers that exercise a judy array search
--judy-ops N stop after N judy array search bogo operations
--judy-size N number of 32 bit integers to insert into judy array
--kcmp N start N workers exercising kcmp
--kcmp-ops N stop after N kcmp bogo operations
--key N start N workers exercising key operations
--key-ops N stop after N key bogo operations
--kill N start N workers killing with SIGUSR1
--kill-ops N stop after N kill bogo operations
--klog N start N workers exercising kernel syslog interface
--klog-ops N stop after N klog bogo operations
--kvm N start N workers exercising /dev/kvm
--kvm-ops N stop after N kvm create/run/destroy operations
--l1cache N start N CPU level 1 cache thrashing workers
--l1cache-line-size N specify level 1 cache line size
--l1cache-sets N specify level 1 cache sets
--l1cache-size N specify level 1 cache size
--l1cache-ways N only fill specified number of cache ways
--landlock N start N workers stressing landlock file operations
--landlock-ops N stop after N landlock bogo operations
--lease N start N workers holding and breaking a lease
--lease-ops N stop after N lease bogo operations
--lease-breakers N number of lease breaking workers to start
--link N start N workers creating hard links
--link-ops N stop after N link bogo operations
--list N start N workers that exercise list structures
--list-ops N stop after N bogo list operations
--list-method M select tlistmethod, all, circleq, insque, list, slist, stailq, tailq
--list-size N N is the number of items in the list
--loadavg N start N workers that create a large load average
--loadavg-ops N stop load average workers after N bogo operations
--locka N start N workers locking a file via advisory locks
--locka-ops N stop after N locka bogo operations
--lockbus N start N workers locking a memory increment
--lockbus-ops N stop after N lockbus bogo operations
--lockf N start N workers locking a single file via lockf
--lockf-ops N stop after N lockf bogo operations
--lockf-nonblock don't block if lock cannot be obtained, re-try
--lockofd N start N workers using open file description locking
--lockofd-ops N stop after N lockofd bogo operations
--longjmp N start N workers exercising setjmp/longjmp
--longjmp-ops N stop after N longjmp bogo operations
--loop N start N workers exercising loopback devices
--loop-ops N stop after N bogo loopback operations
--lsearch N start N workers that exercise a linear search
--lsearch-ops N stop after N linear search bogo operations
--lsearch-size N number of 32 bit integers to lsearch
--madvise N start N workers exercising madvise on memory
--madvise-ops N stop after N bogo madvise operations
--malloc N start N workers exercising malloc/realloc/free
--malloc-bytes N allocate up to N bytes per allocation
--malloc-max N keep up to N allocations at a time
--malloc-ops N stop after N malloc bogo operations
--malloc-thresh N threshold where malloc uses mmap instead of sbrk
--malloc-pthreads N number of pthreads to run concurrently
--malloc-touch touch pages force pages to be populated
--matrix N start N workers exercising matrix operations
--matrix-ops N stop after N maxtrix bogo operations
--matrix-method M specify matrix stress method M, default is all
--matrix-size N specify the size of the N x N matrix
--matrix-yx matrix operation is y by x instead of x by y
--matrix-3d N start N workers exercising 3D matrix operations
--matrix-3d-ops N stop after N 3D maxtrix bogo operations
--matrix-3d-method M specify 3D matrix stress method M, default is all
--matrix-3d-size N specify the size of the N x N x N matrix
--matrix-3d-zyx matrix operation is z by y by x instead of x by y by z
--mcontend N start N workers that produce memory contention
--mcontend-ops N stop memory contention workers after N bogo-ops
--membarrier N start N workers performing membarrier system calls
--membarrier-ops N stop after N membarrier bogo operations
--memcpy N start N workers performing memory copies
--memcpy-ops N stop after N memcpy bogo operations
--memcpy-method M set memcpy method (M = all, libc, builtin, naive)
--memfd N start N workers allocating memory with memfd_create
--memfd-bytes N allocate N bytes for each stress iteration
--memfd-fds N number of memory fds to open per stressors
--memfd-ops N stop after N memfd bogo operations
--memhotplug N start N workers that exercise memory hotplug
--memhotplug-ops N stop after N memory hotplug operations
--memrate N start N workers exercised memory read/writes
--memrate-ops N stop after N memrate bogo operations
--memrate-bytes N size of memory buffer being exercised
--memrate-rd-mbs N read rate from buffer in megabytes per second
--memrate-wr-mbs N write rate to buffer in megabytes per second
--memthrash N start N workers thrashing a 16MB memory buffer
--memthrash-ops N stop after N memthrash bogo operations
--memthrash-method M specify memthrash method M, default is all
--mergesort N start N workers merge sorting 32 bit random integers
--mergesort-ops N stop after N merge sort bogo operations
--mergesort-size N number of 32 bit integers to sort
--mincore N start N workers exercising mincore
--mincore-ops N stop after N mincore bogo operations
--mincore-random randomly select pages rather than linear scan
--misaligned N start N workers performing misaligned read/writes
--misaligned-ops N stop after N misaligned bogo operations
--misaligned-method M use misaligned memory read/write method
--mknod N start N workers that exercise mknod
--mknod-ops N stop after N mknod bogo operations
--mlock N start N workers exercising mlock/munlock
--mlock-ops N stop after N mlock bogo operations
--mlockmany N start N workers exercising many mlock/munlock processes
--mlockmany-ops N stop after N mlockmany bogo operations
--mlockmany-procs N use N child processes to mlock regions
--mmap N start N workers stressing mmap and munmap
--mmap-ops N stop after N mmap bogo operations
--mmap-async using asynchronous msyncs for file based mmap
--mmap-bytes N mmap and munmap N bytes for each stress iteration
--mmap-file mmap onto a file using synchronous msyncs
--mmap-mprotect enable mmap mprotect stressing
--mmap-osync enable O_SYNC on file
--mmap-odirect enable O_DIRECT on file
--mmapaddr N start N workers stressing mmap with random addresses
--mmapaddr-ops N stop after N mmapaddr bogo operations
--mmapfixed N start N workers stressing mmap with fixed mappings
--mmapfixed-ops N stop after N mmapfixed bogo operations
--mmapfork N start N workers stressing many forked mmaps/munmaps
--mmapfork-ops N stop after N mmapfork bogo operations
--mmaphuge N start N workers stressing mmap with huge mappings
--mmaphuge-ops N stop after N mmaphuge bogo operations
--mmaphuge-mmaps N select number of memory mappings per iteration
--mmapmany N start N workers stressing many mmaps and munmaps
--mmapmany-ops N stop after N mmapmany bogo operations
--mprotect N start N workers exercising mprotect on memory
--mprotect-ops N stop after N bogo mprotect operations
--mq N start N workers passing messages using POSIX messages
--mq-ops N stop mq workers after N bogo messages
--mq-size N specify the size of the POSIX message queue
--mremap N start N workers stressing mremap
--mremap-ops N stop after N mremap bogo operations
--mremap-bytes N mremap N bytes maximum for each stress iteration
--mremap-lock mlock remap pages, force pages to be unswappable
--msg N start N workers stressing System V messages
--msg-ops N stop msg workers after N bogo messages
--msg-types N enable N different message types
--msync N start N workers syncing mmap'd data with msync
--msync-ops N stop msync workers after N bogo msyncs
--msync-bytes N size of file and memory mapped region to msync
--msyncmany N start N workers stressing msync on many mapped pages
--msyncmany-ops N stop after N msyncmany bogo operations
--munmap N start N workers stressing munmap
--munmap-ops N stop after N munmap bogo operations
--mutex N start N workers exercising mutex operations
--mutex-ops N stop after N mutex bogo operations
--mutex-affinity change CPU affinity randomly across locks
--mutex-procs N select the number of concurrent processes
--nanosleep N start N workers performing short sleeps
--nanosleep-ops N stop after N bogo sleep operations
--netdev N start N workers exercising netdevice ioctls
--netdev-ops N stop netdev workers after N bogo operations
--netlink-proc N start N workers exercising netlink process events
--netlink-proc-ops N stop netlink-proc workers after N bogo events
--netlink-task N start N workers exercising netlink tasks events
--netlink-task-ops N stop netlink-task workers after N bogo events
--nice N start N workers that randomly re-adjust nice levels
--nice-ops N stop after N nice bogo operations
--nop N start N workers that burn cycles with no-ops
--nop-ops N stop after N nop bogo no-op operations
--nop-instr INSTR specify nop instruction to use
--null N start N workers writing to /dev/null
--null-ops N stop after N /dev/null bogo write operations
--numa N start N workers stressing NUMA interfaces
--numa-ops N stop after N NUMA bogo operations
--oom-pipe N start N workers exercising large pipes
--oom-pipe-ops N stop after N oom-pipe bogo operations
--opcode N start N workers exercising random opcodes
--opcode-ops N stop after N opcode bogo operations
--opcode-method M set opcode stress method (M = random, inc, mixed, text)
-o N, --open N start N workers exercising open/close
--open-ops N stop after N open/close bogo operations
--open-fd open files in /proc/$pid/fd
--pageswap N start N workers that swap pages out and in
--pageswap-ops N stop after N page swap bogo operations
--pci N start N workers that read and mmap PCI regions
--pci-ops N stop after N PCI bogo operations
--personality N start N workers that change their personality
--personality-ops N stop after N bogo personality calls
--peterson N start N workers that exercise Peterson's algorithm
--peterson-ops N stop after N peterson mutex bogo operations
--physpage N start N workers performing physical page lookup
--physpage-ops N stop after N physical page bogo operations
--pidfd N start N workers exercising pidfd system call
--pidfd-ops N stop after N pidfd bogo operations
--ping-sock N start N workers that exercises a ping socket
--ping-sock-ops N stop after N ping sendto messages
-p N, --pipe N start N workers exercising pipe I/O
--pipe-ops N stop after N pipe I/O bogo operations
--pipe-data-size N set pipe size of each pipe write to N bytes
-p N, --pipeherd N start N multi-process workers exercising pipes I/O
--pipeherd-ops N stop after N pipeherd I/O bogo operations
--pipeherd-yield force processes to yield after each write
--pkey N start N workers exercising pkey_mprotect
--pkey-ops N stop after N bogo pkey_mprotect bogo operations
-P N, --poll N start N workers exercising zero timeout polling
--poll-ops N stop after N poll bogo operations
--poll-fds N use N file descriptors
--procfs N start N workers reading portions of /proc
--procfs-ops N stop procfs workers after N bogo read operations
--prefetch N start N workers exercising memory prefetching
--prefetch-ops N stop after N bogo prefetching operations
--prefetch-l3-size N specify the L3 cache size of the CPU
--procfs N start N workers reading portions of /proc
--procfs-ops N stop procfs workers after N bogo read operations
--pthread N start N workers that create multiple threads
--pthread-ops N stop pthread workers after N bogo threads created
--pthread-max P create P threads at a time by each worker
--ptrace N start N workers that trace a child using ptrace
--ptrace-ops N stop ptrace workers after N system calls are traced
--pty N start N workers that exercise pseudoterminals
--pty-ops N stop pty workers after N pty bogo operations
--pty-max N attempt to open a maximum of N ptys
-Q N, --qsort N start N workers qsorting 32 bit random integers
--qsort-ops N stop after N qsort bogo operations
--qsort-size N number of 32 bit integers to sort
--quota N start N workers exercising quotactl commands
--quota-ops N stop after N quotactl bogo operations
--radixsort N start N workers radix sorting random strings
--radixsort-ops N stop after N radixsort bogo operations
--radixsort-size N number of strings to sort
--randlist N start N workers that exercise random ordered list
--randlist-ops N stop after N randlist bogo no-op operations
--randlist-compact reduce mmap and malloc overheads
--randlist-items number of items in the random ordered list
--randlist-size size of data in each item in the list
--ramfs N start N workers exercising ramfs mounts
--ramfs-ops N stop after N bogo ramfs mount operations
--ramfs-bytes N set the ramfs size in bytes, e.g. 2M is 2MB
--rawdev N start N workers that read a raw device
--rawdev-ops N stop after N rawdev read operations
--rawdev-method M specify the rawdev read method to use
--rawpkt N start N workers exercising raw packets
--rawpkt-ops N stop after N raw packet bogo operations
--rawpkt-port P use raw packet ports P to P + number of workers - 1
--rawsock N start N workers performing raw socket send/receives
--rawsock-ops N stop after N raw socket bogo operations
--rawudp N start N workers exercising raw UDP socket I/O
--rawudp-ops N stop after N raw socket UDP bogo operations
--rawudp-if I use network interface I, e.g. lo, eth0, etc.
--rawudp-port P use raw socket ports P to P + number of workers - 1
--rdrand N start N workers exercising rdrand (x86 only)
--rdrand-ops N stop after N rdrand bogo operations
--rdrand-seed use rdseed instead of rdrand
--readahead N start N workers exercising file readahead
--readahead-bytes N size of file to readahead on (default is 1GB)
--readahead-ops N stop after N readahead bogo operations
--reboot N start N workers that exercise bad reboot calls
--reboot-ops N stop after N bogo reboot operations
--remap N start N workers exercising page remappings
--remap-ops N stop after N remapping bogo operations
-R, --rename N start N workers exercising file renames
--rename-ops N stop after N rename bogo operations
--resched N start N workers that spawn renicing child processes
--resched-ops N stop after N nice bogo nice'd yield operations
--resources N start N workers consuming system resources
--resources-ops N stop after N resource bogo operations
--revio N start N workers performing reverse I/O
--revio-ops N stop after N revio bogo operations
--rmap N start N workers that stress reverse mappings
--rmap-ops N stop after N rmap bogo operations
--rmap N start N workers that stress reverse mappings
--rmap-ops N stop after N rmap bogo operations
--rseq N start N workers that exercise restartable sequences
--rseq-ops N stop after N bogo restartable sequence operations
--rtc N start N workers that exercise the RTC interfaces
--rtc-ops N stop after N RTC bogo operations
--schedpolicy N start N workers that exercise scheduling policy
--schedpolicy-ops N stop after N scheduling policy bogo operations
--sctp N start N workers performing SCTP send/receives
--sctp-ops N stop after N SCTP bogo operations
--sctp-if I use network interface I, e.g. lo, eth0, etc.
--sctp-domain D specify sctp domain, default is ipv4
--sctp-port P use SCTP ports P to P + number of workers - 1
--sctp-sched S specify sctp scheduler
--seal N start N workers performing fcntl SEAL commands
--seal-ops N stop after N SEAL bogo operations
--seccomp N start N workers performing seccomp call filtering
--seccomp-ops N stop after N seccomp bogo operations
--secretmem N start N workers that use secretmem mappings
--secretmem-ops N stop after N secretmem bogo operations
--seek N start N workers performing random seek r/w IO
--seek-ops N stop after N seek bogo operations
--seek-punch punch random holes in file to stress extents
--seek-size N length of file to do random I/O upon
--sem N start N workers doing semaphore operations
--sem-ops N stop after N semaphore bogo operations
--sem-procs N number of processes to start per worker
--sem-sysv N start N workers doing System V semaphore operations
--sem-sysv-ops N stop after N System V sem bogo operations
--sem-sysv-procs N number of processes to start per worker
--sendfile N start N workers exercising sendfile
--sendfile-ops N stop after N bogo sendfile operations
--sendfile-size N size of data to be sent with sendfile
-f N, --session N start N workers that exercise new sessions
--session-ops N stop after N session bogo operations
--set N start N workers exercising the set*() system calls
--set-ops N stop after N set bogo operations
--shellsort N start N workers shell sorting 32 bit random integers
--shellsort-ops N stop after N shell sort bogo operations
--shellsort-size N number of 32 bit integers to sort
--shm N start N workers that exercise POSIX shared memory
--shm-ops N stop after N POSIX shared memory bogo operations
--shm-bytes N allocate/free N bytes of POSIX shared memory
--shm-segs N allocate N POSIX shared memory segments per iteration
--shm-sysv N start N workers that exercise System V shared memory
--shm-sysv-ops N stop after N shared memory bogo operations
--shm-sysv-bytes N allocate and free N bytes of shared memory per loop
--shm-sysv-segs N allocate N shared memory segments per iteration
--sigabrt N start N workers generating segmentation faults
--sigabrt-ops N stop after N bogo segmentation faults
--sigchld N start N workers that handle SIGCHLD
--sigchld-ops N stop after N bogo SIGCHLD signals
--sigfd N start N workers reading signals via signalfd reads
--sigfd-ops N stop after N bogo signalfd reads
--sigfpe N start N workers generating floating point math faults
--sigfpe-ops N stop after N bogo floating point math faults
--sigio N start N workers that exercise SIGIO signals
--sigio-ops N stop after N bogo sigio signals
--signal N start N workers that exercise signal
--signal-ops N stop after N bogo signals
--signest N start N workers generating nested signals
--signest-ops N stop after N bogo nested signals
--sigpending N start N workers exercising sigpending
--sigpending-ops N stop after N sigpending bogo operations
--sigpipe N start N workers exercising SIGPIPE
--sigpipe-ops N stop after N SIGPIPE bogo operations
--sigq N start N workers sending sigqueue signals
--sigq-ops N stop after N sigqueue bogo operations
--sigrt N start N workers sending real time signals
--sigrt-ops N stop after N real time signal bogo operations
--sigsegv N start N workers generating segmentation faults
--sigsegv-ops N stop after N bogo segmentation faults
--sigsuspend N start N workers exercising sigsuspend
--sigsuspend-ops N stop after N bogo sigsuspend wakes
--sigtrap N start N workers generating segmentation faults
--sigtrap-ops N stop after N bogo segmentation faults
--skiplist N start N workers that exercise a skiplist search
--skiplist-ops N stop after N skiplist search bogo operations
--skiplist-size N number of 32 bit integers to add to skiplist
--sleep N start N workers performing various duration sleeps
--sleep-ops N stop after N bogo sleep operations
--sleep-max P create P threads at a time by each worker
--smi N start N workers that trigger SMIs
--smi-ops N stop after N SMIs have been triggered
-S N, --sock N start N workers exercising socket I/O
--sock-domain D specify socket domain, default is ipv4
--sock-if I use network interface I, e.g. lo, eth0, etc.
--sock-nodelay disable Nagle algorithm, send data immediately
--sock-ops N stop after N socket bogo operations
--sock-opts option socket options [send|sendmsg|sendmmsg]
--sock-port P use socket ports P to P + number of workers - 1
--sock-protocol use socket protocol P, default is tcp, can be mptcp
--sock-type T socket type (stream, seqpacket)
--sock-zerocopy enable zero copy sends
--sockabuse N start N workers abusing socket I/O
--sockabuse-ops N stop after N socket abusing bogo operations
--sockdiag N start N workers exercising sockdiag netlink
--sockdiag-ops N stop sockdiag workers after N bogo messages
--sockfd N start N workers sending file descriptors over sockets
--sockfd-ops N stop after N sockfd bogo operations
--sockfd-port P use socket fd ports P to P + number of workers - 1
--sockpair N start N workers exercising socket pair I/O activity
--sockpair-ops N stop after N socket pair bogo operations
--sockmany N start N workers exercising many socket connections
--sockmany-ops N stop after N sockmany bogo operations
--sockmany-if I use network interface I, e.g. lo, eth0, etc.
--softlockup N start N workers that cause softlockups
--softlockup-ops N stop after N softlockup bogo operations
--spawn N start N workers spawning stress-ng using posix_spawn
--spawn-ops N stop after N spawn bogo operations
--sparsematrix N start N workers that exercise a sparse matrix
--sparsematrix-ops N stop after N bogo sparse matrix operations
--sparsematrix-method Mselect storage method: all, hash, judy, list or rb
--sparsematrix-items NN is the number of items in the spare matrix
--sparsematrix-size N M is the width and height X x Y of the matrix
--splice N start N workers reading/writing using splice
--splice-ops N stop after N bogo splice operations
--splice-bytes N number of bytes to transfer per splice call
--stack N start N workers generating stack overflows
--stack-ops N stop after N bogo stack overflows
--stack-fill fill stack, touches all new pages
--stack-mlock mlock stack, force pages to be unswappable
--stackmmap N start N workers exercising a filebacked stack
--stackmmap-ops N stop after N bogo stackmmap operations
--str N start N workers exercising lib C string functions
--str-method func specify the string function to stress
--str-ops N stop after N bogo string operations
--stream N start N workers exercising memory bandwidth
--stream-ops N stop after N bogo stream operations
--stream-index specify number of indices into the data (0..3)
--stream-l3-size N specify the L3 cache size of the CPU
--stream-madvise M specify mmap'd stream buffer madvise advice
--swap N start N workers exercising swapon/swapoff
--swap-ops N stop after N swapon/swapoff operations
-s N, --switch N start N workers doing rapid context switches
--switch-ops N stop after N context switch bogo operations
--switch-freq N set frequency of context switches
--switch-method M mq | pipe | sem-sysv
--symlink N start N workers creating symbolic links
--symlink-ops N stop after N symbolic link bogo operations
--sync-file N start N workers exercise sync_file_range
--sync-file-ops N stop after N sync_file_range bogo operations
--sync-file-bytes N size of file to be sync'd
--syncload N start N workers that synchronize load spikes
--syncload-ops N stop after N syncload bogo operations
--syncload-msbusy M maximum busy duration in milliseconds
--syncload-mssleep M maximum sleep duration in milliseconds
--sysbadaddr N start N workers that pass bad addresses to syscalls
--sysbadaddr-ops N stop after N sysbadaddr bogo syscalls
--sysinfo N start N workers reading system information
--sysinfo-ops N stop after sysinfo bogo operations
--sysinval N start N workers that pass invalid args to syscalls
--sysinval-ops N stop after N sysinval bogo syscalls
--sysfs N start N workers reading files from /sys
--sysfs-ops N stop after sysfs bogo operations
--tee N start N workers exercising the tee system call
--tee-ops N stop after N tee bogo operations
-T N, --timer N start N workers producing timer events
--timer-ops N stop after N timer bogo events
--timer-freq F run timer(s) at F Hz, range 1 to 1000000000
--timer-rand enable random timer frequency
--timerfd N start N workers producing timerfd events
--timerfd-ops N stop after N timerfd bogo events
--timerfd-fds N number of timerfd file descriptors to open
--timerfd-freq F run timer(s) at F Hz, range 1 to 1000000000
--timerfd-rand enable random timerfd frequency
--tlb-shootdown N start N workers that force TLB shootdowns
--tlb-shootdown-ops N stop after N TLB shootdown bogo ops
--tmpfs N start N workers mmap'ing a file on tmpfs
--tmpfs-ops N stop after N tmpfs bogo ops
--tmpfs-mmap-async using asynchronous msyncs for tmpfs file based mmap
--tmpfs-mmap-file mmap onto a tmpfs file using synchronous msyncs
--touch N start N stressors that touch and remove files
--touch-ops N stop after N touch bogo operations
--touch-opts touch open options all,direct,dsync,excl,noatime,sync,trunc
--touch-method specify method to touch tile file, open | create
--tree N start N workers that exercise tree structures
--tree-ops N stop after N bogo tree operations
--tree-method M select tree method: all,avl,binary,btree,rb,splay
--tree-size N N is the number of items in the tree
--tsc N start N workers reading the time stamp counter
--tsc-ops N stop after N TSC bogo operations
--tsearch N start N workers that exercise a tree search
--tsearch-ops N stop after N tree search bogo operations
--tsearch-size N number of 32 bit integers to tsearch
--tun N start N workers exercising tun interface
--tun-ops N stop after N tun bogo operations
--tun-tap use TAP interface instead of TUN
--udp N start N workers performing UDP send/receives
--udp-ops N stop after N udp bogo operations
--udp-domain D specify domain, default is ipv4
--udp-gro enable UDP-GRO
--udp-lite use the UDP-Lite (RFC 3828) protocol
--udp-port P use ports P to P + number of workers - 1
--udp-if I use network interface I, e.g. lo, eth0, etc.
--udp-flood N start N workers that performs a UDP flood attack
--udp-flood-ops N stop after N udp flood bogo operations
--udp-flood-domain D specify domain, default is ipv4
--udp-flood-if I use network interface I, e.g. lo, eth0, etc.
--unshare N start N workers exercising resource unsharing
--unshare-ops N stop after N bogo unshare operations
--uprobe N start N workers that generate uprobe events
--uprobe-ops N stop after N uprobe events
-u N, --urandom N start N workers reading /dev/urandom
--urandom-ops N stop after N urandom bogo read operations
--userfaultfd N start N page faulting workers with userspace handling
--userfaultfd-ops N stop after N page faults have been handled
--sigsusr N start N workers exercising a userspace system call handler
--sigsusr-ops N stop after N successful SIGSYS system callls
--utime N start N workers updating file timestamps
--utime-ops N stop after N utime bogo operations
--utime-fsync force utime meta data sync to the file system
--vdso N start N workers exercising functions in the VDSO
--vdso-ops N stop after N vDSO function calls
--vdso-func F use just vDSO function F
--vecmath N start N workers performing vector math ops
--vecmath-ops N stop after N vector math bogo operations
--vecwide N start N workers performing vector math ops
--vecwide-ops N stop after N vector math bogo operations
--verity N start N workers exercising file verity ioctls
--verity-ops N stop after N file verity bogo operations
--vfork N start N workers spinning on vfork() and exit()
--vfork-ops N stop after N vfork bogo operations
--vfork-max P create P processes per iteration, default is 1
--vfork-vm enable extra virtual memory pressure
--vforkmany N start N workers spawning many vfork children
--vforkmany-ops N stop after spawning N vfork children
--vforkmany-vm enable extra virtual memory pressure
-m N, --vm N start N workers spinning on anonymous mmap
--vm-bytes N allocate N bytes per vm worker (default 256MB)
--vm-hang N sleep N seconds before freeing memory
--vm-keep redirty memory instead of reallocating
--vm-ops N stop after N vm bogo operations
--vm-madvise M specify mmap'd vm buffer madvise advice
--vm-method M specify stress vm method M, default is all
--vm-addr N start N vm address exercising workers
--vm-addr-ops N stop after N vm address bogo operations
--vm-rw N start N vm read/write process_vm* copy workers
--vm-rw-bytes N transfer N bytes of memory per bogo operation
--vm-rw-ops N stop after N vm process_vm* copy bogo operations
--vm-segv N start N workers that unmap their address space
--vm-segv-ops N stop after N vm-segv unmap'd SEGV faults
--vm-splice N start N workers reading/writing using vmsplice
--vm-splice-ops N stop after N bogo splice operations
--vm-splice-bytes N number of bytes to transfer per vmsplice call
--wait N start N workers waiting on child being stop/resumed
--wait-ops N stop after N bogo wait operations
--watchdog N start N workers that exercise /dev/watchdog
--watchdog-ops N stop after N bogo watchdog operations
--wcs N start N workers on lib C wide char string functions
--wcs-method func specify the wide character string function to stress
--wcs-ops N stop after N bogo wide character string operations
--x86syscall N start N workers exercising functions using syscall
--x86syscall-ops N stop after N syscall function calls
--x86syscall-func F use just syscall function F
--xattr N start N workers stressing file extended attributes
--xattr-ops N stop after N bogo xattr operations
-y N, --yield N start N workers doing sched_yield() calls
--yield-ops N stop after N bogo yield operations
--zero N start N workers reading /dev/zero
--zero-ops N stop after N /dev/zero bogo read operations
--zlib N start N workers compressing data with zlib
--zlib-level L specify zlib compression level 0=fast, 9=best
--zlib-mem-level L specify zlib compression state memory usage 1=minimum, 9=maximum
--zlib-method M specify zlib random data generation method M
--zlib-ops N stop after N zlib bogo compression operations
--zlib-strategy S specify zlib strategy 0=default, 1=filtered, 2=huffman only, 3=rle, 4=fixed
--zlib-stream-bytes S specify the number of bytes to deflate until the current stream will be closed
--zlib-window-bits W specify zlib window bits -8-(-15) | 8-15 | 24-31 | 40-47
--zombie N start N workers that rapidly create and reap zombies
--zombie-ops N stop after N bogo zombie fork operations
--zombie-max N set upper limit of N zombies per worker
Example: stress-ng --cpu 8 --io 4 --vm 2 --vm-bytes 128M --fork 4 --timeout 10s
Note: Sizes can be suffixed with B,K,M,G and times with s,m,h,d,y
This example stressed the most out of my system. Change the --cpu parameter according to your CPU cores.
$ stress-ng --cpu 8 --cpu-method idct --matrix 20 --matrix-method mean --maximize
stress-ng: info: [40671] defaulting to a 86400 second (1 day, 0.00 secs) run per stressor
stress-ng: info: [40671] dispatching hogs: 8 cpu, 20 matrix
^Cstress-ng: info: [40671] successful run completed in 145.56s (2 mins, 25.56 secs)