stress-ng, version 0.22.02 (gcc 16.2.0, x86_64 Linux 6.18.60-r0-gcp-6.18)
usage: stress-ng [OPTION [ARG]]
general control options:
--abort abort all stressors if any stressor fails
--aggressive enable all aggressive options
--autogroup set /proc/self/autogroup when nice(2) is used
-a N, --all N start N workers of each stress test
-b N, --backoff N wait of N microseconds before work starts
--buddystat S show Linux buddy allocator info every S seconds
--buildinfo show build information
--c-states report CPU C-state residencies
--change-cpu force child processes to use different CPU to
that of parent
--class name specify a class of stressors, use with
--sequential
--compact-memory attempt to compact memory before stressor is
started
--config show build configuration settings
--dentrystat S show Linux dentry cache usage info every S
seconds
-n, --dry-run do not run
--drop-caches drop page cache, inode and dentry caches (Linux
only)
--exercised show features, libraries and system calls used by
a stressor
--exercise-feature list select stressors by a list of stress features
--exercise-library list select stressors by a list of libraries used
--exercise-syscall list select stressors by a list of system calls
heavily used
--ftrace enable kernel function call tracing
-h, --help show help
--ignite-cpu alter kernel controls to make CPU run hot
--interrupts check for error interrupts
--ionice-class C specify ionice class (idle, besteffort, realtime)
--ionice-level L specify ionice level (0 max, 7 min)
--ios report I/O average read/write rates
-I, --iostat S show I/O statistics every S seconds
-j, --job jobfile run the named jobfile
--keep-files do not remove files or directories
-k, --keep-name keep stress worker names to be 'stress-ng'
-K, --klog-check check kernel message log for errors
--ksm enable kernel samepage merging
--limit-as N set size limit on process's address space usage
--limit-data N set size limit on process's data segment usage
--limit-stack N set size limit on process's stack usage
--log-brief less verbose log messages
-L, --log-file filename log messages to a log file
--log-lockless log messages without message locking
--make-it-fail enable per stressor process fault injection
failures
--maximize enable maximum stress options
--max-fd N set maximum file descriptor limit
--mbind set NUMA memory binding to specific nodes
-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-madvise-opts list specify a list of madvise advice not to use
--no-oom-adjust disable all forms of out-of-memory score
adjustments
--no-rand-seed seed random numbers with the same constant
--oom-avoid try to avoid stressors from being OOM'd
--oom-avoid-bytes N number of bytes free to stop further memory
allocations
--oom-no-child disable sub-child process for OOM'able stressors
--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
--pause N pause N seconds between each stressor start
--perf display perf statistics
--permute N run permutations of stressors with N stressors
per permutation
--progress show run progress
-q, --quiet quiet output
-r, --random N start N random workers
--randprocname randomize stressor process name
--rapl report RAPL power domain measurements over entire
run (Linux x86 only)
--raplstat S show RAPL power domain stats every S seconds
(Linux x86 only)
--resctrl list specify resource control cache partitioning
--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
--settings report option settings
--sequential N run all stressors one by one, invoking N of them
--skip-silent silently skip unimplemented stressors
--smart show changes in S.M.A.R.T. data
--sn use scientific notation for metrics
--status S show stress-ng progress status every S seconds
--stderr all output to stderr
--stdout all output to stdout (now the default)
--stressor-time log start and end run times of each stressor
--stressors show available stress tests
--syslog log messages to the syslog
--taskset use specific CPUs (set CPU affinity)
--temp-path path specify path for temporary directories and files
--thermalstat S show CPU and thermal load stats every S seconds
--thrash force all pages in causing swap thrashing
-t N, --timeout T timeout after T seconds
--timer-slack N set slack slack to N nanoseconds, 0 for default
--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
--vmstat S show memory and process statistics every S
seconds
--vmstat-units U vmstat memory units, one of k | m | g | t | p | e
-w, --with list specify stressors to run with --all, --seq,
--permute
-x, --exclude list list of stressors to exclude (not run)
-w, --with list list of stressors to invoke (use with --seq or
--all)
-Y, --yaml file output results to YAML formatted file
stressor specific options:
--access N start N workers that stress file access
permissions
--access-ops N stop after N file access bogo operations
--acl N start N workers exercising valid ACL file mode
bits
--acl-rand randomize ordering of ACL file mode tests
--acl-ops N stop acl workers after N bogo operations
--acct N start N workers exercising process accounting
--acct-ops N stop after reading N process exiting accounting
records
--af-alg N start N workers that stress AF_ALG socket domain
--af-alg-dump dump internal list from /proc/crypto to stdout
--af-alg-ops N stop after N af-alg bogo operations
--af-alg-type type crypto type [ all | ahash | shash | skcipher |
rng | aead ]
--affinity N start N workers that rapidly change CPU affinity
--affinity-delay D delay in nanoseconds between affinity changes
--affinity-ops N stop after N affinity bogo operations
--affinity-pin keep per stressor threads pinned to same CPU
--affinity-procs N number of child processes to run per affinity
instance
--affinity-rand change affinity randomly rather than sequentially
--affinity-sleep N 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
--alarm N start N workers exercising alarm timers
--alarm-ops N stop after N alarm bogo operations
--apparmor start N workers exercising AppArmor interfaces
--apparmor-ops N stop after N bogo AppArmor worker 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 ioctls on
devices
--bad-ioctl-alldev exercise all devices (rather than just
/dev/devname0
--bad-ioctl-method M method of selecting ioctl command [ random | inc
| random-inc | stride ]
--bad-ioctl-ops N stop after N bad ioctl bogo operations
--besselmath N start N workers exercising bessel math functions
--besselmath-method M select bessel math function to exercise
--besselmath-ops N stop after N besselmath bogo bessel math
operations
-B N, --bigheap N start N workers that grow the heap using
realloc()
--bigheap-bytes N grow heap up to N bytes in total
--bigheap-growth N grow heap by N bytes per iteration
--bigheap-mlock attempt to mlock newly mapped pages
--bigheap-ops N stop after N bogo bigheap operations
--binderfs N start N workers exercising binderfs
--binderfs-ops N stop after N bogo binderfs operations
--bind-mount N start N workers exercising bind mounts
--bind-mount-ops N stop after N bogo bind mount operations
--bitonicsort N start N workers bitonic sorting 32 bit random
integers
--bitonicsort-ops N stop after N bitonic sort bogo operations
--bitonicsort-size N number of 32 bit integers to sort
--bitops N start N workers that perform CPU only loading
--bitops-method M specify stress bitops method M, default is all
--bitops-ops N stop after N bitops bogo operations
--bpf N start N workers exercising random BPF
instructions
--bpf-max specify maximum number of BPF instructions
--bpf-ops N stop after N BPF system calls
--branch N start N workers that force branch misprediction
--branch-jumps N number of branches [ 64 | 128 | 256 | 512 | 1024
| 2048
--branch-ops N stop after N branch misprediction branches
--brk N start N workers performing rapid brk calls
--brk-bytes N grow brk region up to N bytes in total
--brk-mlock attempt to mlock newly mapped brk pages
--brk-notouch don't touch (page in) new data segment page
--brk-ops N stop after N brk bogo operations
--bsearch N start N workers that exercise a binary search
--bsearch-method M select bsearch method [ bsearch-libc |
bsearch-nonlibc ]
--bsearch-ops N stop after N binary search bogo operations
--bsearch-size N number of 32 bit integers to bsearch
--bubblesort N start N workers bubble sorting 32 bit random
integers
--bubblesort-method M select sort method [ bubblesort-fast |
bubblesort-naive
--bubblesort-ops N stop after N bubblesort bogo operations
--bubblesort-size N number of 32 bit integers to sort
-C N, --cache N start N CPU cache thrashing workers
--cache-badpage cache flush on unmapped (bad) page
--cache-cldemote cache line demote (x86 only)
--cache-clflushopt optimized cache line flush (x86 only)
--cache-clwb cache line writeback (x86 / RISC-V)
--cache-enable-all enable all cache options
(fence,flush,sfence,etc..)
--cache-fence serialize stores
--cache-flush flush cache after every memory write (x86 /
RISC-V)
--cache-level N only exercise specified cache
--cache-no-affinity do not change CPU affinity
--cache-ops N stop after N cache bogo operations
--cache-permute permute (mix) cache operations
--cache-prefetch prefetch for memory reads/writes
--cache-prefetchw prefetch for memory write
--cache-sfence serialize stores with sfence
--cache-size N override the default cache size setting to N
bytes
--cache-ways N only fill specified number of cache ways
--cachehammer N start N CPU cache thrashing workers
--cachehammer-method select hammering method [ permute | random ]
--cachehammer-numa move pages to randomly chosen NUMA nodes
--cachehammer-ops N stop after N cache bogo operations
--cacheline N start N workers that exercise cachelines
--cacheline-affinity modify CPU affinity
--cacheline-method M use cacheline stressing method M
--cacheline-ops N stop after N cacheline bogo operations
--cap N start N workers exercising capget and capset
--cap-ops N stop cap workers after N bogo capget/capset
operations
--cgroup N start N workers exercising cgroup
mount/read/write/umounts
--cgroup-ops N stop after N iterations of cgroup actions
--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-dirs N select number of directories to exercise chdir on
--chdir-ops N stop chdir workers after N bogo chdir operations
--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
--chyperbolic N start N workers exercising complex hyperbolic
functions
--chyperbolic-method M select complex hyperbolic function to exercise
--chyperbolic-ops N stop after N chyperbolic bogo complex hyperbolic
function 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-max N set upper limit of N clones per worker
--clone-ops N stop after N bogo clone operations
--close N start N workers that exercise races on close
--close-fds specify the number of file descriptors to
exercise
--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-bytes N specify size of file to be copied
--copy-file-io-bytes N specify copying I/O size
--copy-file-ops N stop after N copy bogo operations
-c N, --cpu N start N workers that perform CPU only loading
-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-ops N stop after N cpu bogo operations
--cpu-online N start N workers offlining/onlining the CPUs
--cpu-online-affinity set CPU affinity to the CPU to be offlined
--cpu-online-all attempt to exercise all CPUs include CPU 0
--cpu-online-ops N stop after N offline/online operations
--cpu-sched N start N workers that exercise cpu scheduling
--cpu-sched-ops N stop after N bogo cpu scheduling operations
--cpu-sched-procs N specify number of processes per instance
--crc N start N workers performing Cyclic Rundundancy
Check ops
--crc-ops N stop after N Cyclic Rundundancy Check bogo
operations
--crypt N start N workers performing password encryption
--crypt-method M select encryption method [ all | MD5 | NT | SHA-1
| SHA-256 | SHA-512 | scrypt | SunMD5 | yescrypt]
--crypt-ops N stop after N bogo crypt operations
--ctrig N start N workers exercising complex trigonometric
functions
--ctrig-method M select complex trigonometric function to exercise
--ctrig-ops N stop after N trig bogo complex trigonometric
operations
--cyclic N start N cyclic real time benchmark stressors
--cyclic-budget N fail if any latency sample exceeds N nanoseconds
--cyclic-dist N calculate distribution of interval N nanosecs
--cyclic-method M specify cyclic method M, default is clock_ns
--cyclic-ops N stop after N cyclic timing cycles
--cyclic-policy P used rr or fifo scheduling policy
--cyclic-prio N real time scheduling priority 1..100
--cyclic-samples N number of latency samples to take
--cyclic-sleep N sleep time of real time timer in nanosecs
--daemon N start N workers creating multiple daemons
--daemon-bloat N specify N bytes of daemon child process memory
bloat
--daemon-ops N stop when N daemons have been created
--daemon-wait stressor wait for daemon to exit and not init
--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
--dccp-msgs N number of DCCP messages to send per connection
--dekker N start N workers that exercise the 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
--dentrycache N start N dentry thrashing stressors
--dentrycache-method M select dentrycache negative access method M
--dentrycache-ops N stop after N dentry bogo operations
--dev N start N device entry thrashing stressors
--dev-alldev exercise all devices (rather than just
/dev/devname0)
--dev-file name specify the /dev/ file to exercise
--dev-ops N stop after N device thrashing bogo ops
--dev-shm N start N /dev/shm file and mmap stressors
--dev-shm-ops N stop after N /dev/shm bogo ops
--dfp N start N workers performing decimal floating point
math ops
--dfp-method M select the decimal floating point method to
operate with
--dfp-ops N stop after N decimal floating point math bogo
operations
--dir N start N directory thrashing stressors
--dir-dirs N select number of directories to exercise dir on
--dir-ops N stop after N directory bogo operations
--dirdeep N start N directory depth stressors
--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 %)
--dirdeep-ops N stop after N directory depth bogo operations
--dirmany N start N directory file populating stressors
--dirmany-bytes specify size of files (default 0)
--dirmany-ops N stop after N directory file bogo operations
--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
--easy-opcode N start N workers exercising random easy opcodes
--easy-opcode-ops N stop after N easy opcode bogo operations
--efivar N start N workers that read EFI variables
--efivar-ops N stop after N EFI variable bogo read operations
--eigen N start N workers exercising eigen operations
--eigen-method M specify eigen stress method M, default is all
--eigen-ops N stop after N matrix bogo operations
--eigen-size N specify the size of the N x N eigen
--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-domain D specify socket domain, default is unix
--epoll-ops N stop after N epoll bogo operations
--epoll-port P use socket ports P upwards
--epoll-sockets N specify maximum number of open sockets
--epollmany N start N workers doing epoll exercising
--epollmany-delete delete fds from epoll descriptors before close
--epollmany-fds N specify number of epoll_create fds to exercise
--epollmany-ops N stop after N epoll bogo operations
--eth_sniff N start N workers sniffing ethernet packets
--eth_sniff-ops N stop after N bogo sniffing ethernet packet
operations
--eventfd N start N workers stressing eventfd read/writes
--eventfd-nonblock poll with non-blocking I/O on eventfd fd
--eventfd-ops N stop eventfd workers after N bogo operations
--exec N start N workers spinning on fork() and exec()
--exec-fork-method M select exec fork method: clone fork spawn vfork
--exec-max P create P workers per iteration, default is 4096
--exec-method M select exec method: all, execve, execveat
--exec-no-pthread do not use pthread_create
--exec-ops N stop after N exec bogo operations
--exit-group N start N workers that exercise exit_group
--exit-group-ops N stop exit_group workers after N bogo exit_group
loops
--expmath N start N workers exercising exponential math
functions
--expmath-method M select exponential math function to exercise
--expmath-ops N stop after N expmath bogo exponential math
operations
--factor N start N workers performing large integer
factorization
--factor-digits N specific number of digits of number to factor
--factor-ops N stop after N factorisation operations
--fallocate N start N workers fallocating 16MB files
--fallocate-bytes N specify size of file to allocate
--fallocate-ops N stop after N fallocate bogo operations
--fanotify N start N workers exercising fanotify events
--fanotify-ops N stop fanotify workers after N bogo operations
--far-branch N start N far branching workers
--far-branch-flush periodically flush instruction cache
--far-branch-ops N stop after N far branching bogo operations
--far-branch-pageout soft offline and/or pageout object code pages
--far-branch-pages N number of pages to populate with functions
--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
--fd-abuse N start N workers abusing file descriptors
--fd-abuse-ops N stop fd-abuse after bogo operations
--fd-fork N start N workers exercising dup/fork/close
--fd-fork-fds N set maximum number of file descriptors to use
--fd-fork-file file select file to dup [ null, random, stdin, stdout,
zero ]
--fd-fork-ops N stop after N dup/fork/close bogo operations
--fd-race N start N workers sending file descriptors over
sockets
--fd-race-dev race on /dev/* files
--fd-race-ops N stop after N fd_race bogo operations
--fd-race-proc race on /proc/* files
--fibsearch N start N workers that exercise a Fibonacci search
--fibsearch-ops N stop after N Fibonacci search bogo operations
--fibsearch-size N number of 32 bit integers to Fibonacci search
--fiemap N start N workers exercising the FIEMAP ioctl
--fiemap-bytes N specify size of file to fiemap
--fiemap-ops N stop after N FIEMAP ioctl bogo operations
--fifo N start N workers exercising fifo I/O
--fifo-data-size N set fifo read/write size in bytes (default 8)
--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
--filehole N start N workers punching holes in a 16MB file
--filehole-bytes N size of file being punched
--filehole-defrag defragment file at end of each iteration
--filehole-ops N stop after N punch 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
--filerace N start N workers that attempt to race file system
calls
--filerace-files N race on N files, 1..256
--filerace-ops N stop after N filerace bogo operations
--filerace-procs N specify number of processes per instance
--flipflop N start N workers exercising flipflop
--flipflop-bits N number of bits to be exercised by 2 x N x
pthreads
--flipflop-ops N stop after N flipflop bogo operations
--flipflop-taskset1 S1 list of CPUs to pin N ping threads to
--flipflop-taskset2 S2 list of CPUs to pin N pong threads to
--flock N start N workers locking a single file
--flock-ops N stop after N flock bogo operations
--flushcache N start N CPU instruction + data cache flush
workers
--flushcashe-d-bytes specify data cache size
--flushcashe-i-bytes specify instruction cache size
--flushcache-ops N stop after N flush cache bogo operations
--fma N start N workers performing floating point
multiply-add ops
--fma-libc use fma libc fused multiply-add helpers
--fma-ops N stop after N floating point multiply-add bogo
operations
-f N, --fork N start N workers spinning on fork() and exit()
--fork-max P create P forked processes per iteration, default
is 1
--fork-ops N stop after N fork bogo operations
--fork-pageout force pageout memory resident pages
--fork-unmap forcibly unmap unused shared library pages
(dangerous)
--fork-vm enable extra virtual memory pressure
--forkheavy N start N workers that rapidly fork and reap
resource heavy processes
--forkheavy-allocs N attempt to allocate N x resources
--forkheavy-mlock attempt to mlock newly mapped pages
--forkheavy-ops N stop after N bogo fork operations
--forkheavy-procs N attempt to fork N processes
--fp N start N workers performing floating point math
ops
--fp-method M select the floating point method to operate with
--fp-ops N stop after N floating point math bogo operations
--fp-error N start N workers exercising floating point errors
--fp-error-ops N stop after N fp-error bogo operations
--fp-misc N start N workers performing miscellaneous floating
point operations
--fp-misc-ops N stop after N floating point miscellaneous bogo
operations
--fp-subnormal N start N workers performing subnormal floating
point math ops
--fp-subnormal-method M select the subnormal floating point method to
operate with
--fp-subnormal-ops N stop after N subnormal floating point math bogo
operations
--fpunch N start N workers punching holes in a 16MB file
--fpunch-bytes N size of file being punched
--fpunch-ops N stop after N punch bogo operations
--fractal N start N workers performing large integer
fractalization
--fractal-iterations N number of iterations
--fractal-method M fractal method [ mandelbrot | julia ]
--fractal-ops N stop after N fractalisation operations
--fractal-xsize N width of fractal
--fractal-ysize N height of fractal
--fsize N start N workers exercising file size limits
--fsize-ops N stop after N fsize bogo operations
--fstat N start N workers exercising fstat on files
--fstat-dir path fstat files in the specified directory
--fstat-ops N stop after N fstat bogo operations
--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-method M select function call method M
--funccall-ops N stop after N function call bogo operations
--funcret N start N workers exercising function return
copying
--funcret-method M select method of exercising a function return
type
--funcret-ops N stop after N function return bogo operations
--futex N start N workers exercising a fast mutex
--futex-ops N stop after N fast mutex bogo operations
--gamma N start N workers exercising gamma functions
--gamma-method M select gamma function to exercise
--gamma-ops N stop after N gamma bogo operations
--get N start N workers exercising the get*() system
calls
--get-ops N stop after N get bogo operations
--get-slow-sync synchronize get*() system amongst N workers
--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-direction D select goto direction forward, backward, random
--goto-ops N stop after 1024 x N goto bogo operations
--gpu N start N GPU worker
--gpu-devnode name specify GPU device node name
--gpu-frag N specify shader core usage per pixel
--gpu-ops N stop after N gpu render bogo operations
--gpu-tex-size N specify upload texture N x N
--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-method M specify stress hash method M, default is all
--hash-ops N stop after N hash bogo operations
-d N, --hdd N start N workers spinning on write()/unlink()
--hdd-bytes N write N bytes per hdd worker (default is 1GB)
--hdd-ops N stop after N hdd bogo operations
--hdd-opts list specify list of various stressor options
--hdd-sleep N sleep N seconds after each read/write cycle
(default is off)
--hdd-write-size N set the default write size to N bytes
--heapsort N start N workers heap sorting 32 bit random
integers
--heapsort-method M select sort method [ heapsort-libc |
heapsort-nonlibc ]
--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-adjust adjust rate to try and maximize timer rate
--hrtimers-ops N stop after N bogo high-res timer bogo operations
--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
--hugepage N start N workers that split and merge pages on
huge pages
--hugepage-dontneed madvise MADV_DONTNEED on page size chunks of
hugepage
--hugepage-method select method of splitting [ forward | random |
reverse ]
--hugepage-num N number of hugepages
--hugepage-ops N stop hugepage workers after N bogo huge page
rebuild operations
--hugepage-remove madvise MADV_REMOVE on page size chunks of
hugepage
--hyperbolic N start N workers exercising hyperbolic functions
--hyperbolic-method M select hyperbolic function to exercise
--hyperbolic-ops N stop after N hyperbolic bogo hyperbolic function
operations
--icache N start N CPU instruction cache thrashing workers
--icache-ops N stop after N icache bogo operations
--icache-pages N specify number of pages to cache thrash
--icmp-flood N start N ICMP packet flood workers
--icmp-flood-max-size use randomized packet sizes up to 65535 bytes
--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
--insertionsort N start N workers insertion sorting 32 bit random
integers
--insertionsort-ops N stop after N insertion sort bogo operations
--insertionsort-size N number of 32 bit integers to sort
--intmath N start N workers that exercising signed integer
math operations
--intmath-fast use int_fast*_t fast integers
--intmath-method select the method of integer math operation
--intmath-ops N stop after N bogo signed integer math 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
--ioport-opts O option to select ioport access [ in | out | inout
]
--ioport-port post | vga-dac-r | bochs-debug
--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-entries N specify number if io-uring ring entries
--io-uring-ops N stop after N bogo io-uring I/O requests
--io-uring-rand enable randomized io-uring I/O request ordering
--ipsec-mb N start N workers exercising the IPSec MB encoding
--ipsec-mb-feature F specify CPU feature F
--ipsec-mb-jobs N specify number of jobs to run per round (default
1)
--ipsec-mb-method M specify crypto/integrity method
--ipsec-mb-ops N stop after N ipsec bogo encoding operations
--itimer N start N workers exercising interval timers
--itimer-freq F set the itimer frequency, limited by jiffy clock
rate
--itimer-ops N stop after N interval timer bogo operations
--itimer-rand enable random interval timer frequency
--jpeg N start N workers that perform jpeg image
compression
--jpeg-height N image height in pixels
--jpeg-image type image type: one of brown, flat, gradient, noise,
plasma or xstripes
--jpeg-ops N stop after N jpeg bogo no-op operations
--jpeg-quality Q compression quality 1 (low) .. 100 (high)
--jpeg-width N image width in pixels
--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-method M l1 cache thrashing method: forward, reverse,
random
--l1cache-mlock attempt to mlock memory
--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-breakers N number of lease breaking workers to start
--lease-ops N stop after N lease bogo operations
--led N start N workers that read and set LED settings
--led-ops N stop after N LED bogo operations
--link N start N workers creating hard links
--link-ops N stop after N link bogo operations
--link-sync enable sync'ing after linking/unlinking
--list N start N workers that exercise list structures
--list-method M select list method: all, circleq, list, slist,
slistt, stailq, tailq
--list-ops N stop after N bogo list operations
--list-size N N is the number of items in the list
--llc-affinity N start N workers exercising low level cache over
all CPUs
--llc-affinity-clflush enable cache line flushing on memory
--llc-affinity-mlock attempt to mlock pages into memory
--llc-affinity-numa bind memory mappings to randomly selected NUMA
nodes
--llc-affinity-ops N stop after N low-level-cache bogo operations
--loadavg N start N workers that create a large load average
--loadavg-max N set upper limit on number of pthreads to create
--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-bytes N size of lockbus memory region
--lockbus-nosplit disable split locks
--lockbus-ops N stop after N lockbus bogo operations
--lockf N start N workers locking a single file via lockf
--lockf-nonblock don't block if lock cannot be obtained, re-try
--lockf-ops N stop after N lockf bogo operations
--lockmix N start N workers locking a file via flock, locka,
lockf and ofd locks
--lockmix-ops N stop after N lockmix bogo operations
--lockofd N start N workers using open file description
locking
--lockofd-ops N stop after N lockofd bogo operations
--logmath N start N workers exercising logarithmic math
functions
--logmath-method M select logarithmic math function to exercise
--logmath-ops N stop after N logmath bogo logarithmic math
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-bytes N set maximum size of loopback device
--loop-ops N stop after N bogo loopback operations
--lsearch N start N workers that exercise a linear search
--lsearch-method M select lsearch method [ lsearch-libc |
lsearch-nonlibc ]
--lsearch-ops N stop after N linear search bogo operations
--lsearch-size N number of 32 bit integers to lsearch
--lsm N start N workers that exercise lsm kernel system
calls
--lsm-ops N stop after N lsm bogo operations
--madvise N start N workers exercising madvise on memory
--madvise-bytes N specify size of memory being madvise'd
--madvise-hwpoison enable hardware page poisoning (disabled by
default)
--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-mlock attempt to mlock pages into memory
--malloc-ops N stop after N malloc bogo operations
--malloc-pthreads N number of pthreads to run concurrently
--malloc-thresh N threshold where malloc uses mmap instead of sbrk
--malloc-touch touch pages force pages to be populated
--malloc-trim enable malloc trimming
--malloc-zerofree zero free'd memory
--matrix N start N workers exercising matrix operations
--matrix-method M specify matrix stress method M, default is all
--matrix-ops N stop after N matrix bogo operations
--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-method M specify 3D matrix stress method M, default is all
--matrix-3d-ops N stop after N 3D matrix bogo operations
--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-numa bind memory mappings to randomly selected NUMA
nodes
--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-method M set memcpy method (M = all, libc, builtin,
naive..)
--memcpy-ops N stop after N memcpy bogo operations
--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-madvise add random madvise hints to memfd mapped pages
--memfd-mlock attempt to mlock pages into memory
--memfd-numa bind memory mappings to randomly selected NUMA
nodes
--memfd-ops N stop after N memfd bogo operations
--memfd-zap-pte enable zap pte bug check (slow)
--memhotplug N start N workers that exercise memory hotplug
--memhotplug-mmap enable random memory mapping/unmapping
--memhotplug-ops N stop after N memory hotplug operations
--memrate N start N workers exercised memory read/writes
--memrate-bytes N size of memory buffer being exercised
--memrate-discontiguous make mmap'd physical pages discontiguous
--memrate-flush flush cache before each iteration
--memrate-method M specify read/write memory exercising method
--memrate-ops N stop after N memrate bogo operations
--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-method M specify memthrash method M, default is all
--memthrash-ops N stop after N memthrash bogo operations
--mergesort N start N workers merge sorting 32 bit random
integers
--mergesort-method M select sort method [ method-libc | method-nonlibc
--mergesort-ops N stop after N merge sort bogo operations
--mergesort-size N number of 32 bit integers to sort
--metamix N start N workers that have a mix of file metadata
operations
--metamix-bytes N write N bytes per metamix file (default is 1MB,
16 files per instance)
--metamix-ops N stop metamix workers after N metamix bogo
operations
--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
--min-nanosleep N start N workers performing short sleeps
--min-nanosleep-ops N stop after N bogo sleep operations
--min-nanosleep-max N maximum nanosleep delay to be used
--min-nanosleep-sched P select scheduler policy [ batch, deadline, idle,
fifo, other, rr ]
--misaligned N start N workers performing misaligned read/writes
--misaligned-method M use misaligned memory read/write method
--misaligned-ops N stop after N misaligned bogo operations
--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-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-madvise enable random madvise on mmap'd region
--mmap-mergeable where possible, flag mmap'd pages as mergeable
--mmap-mlock attempt to mlock mmap'd pages
--mmap-mmap2 use mmap2 instead of mmap (when available)
--mmap-mprotect enable mmap mprotect stressing
--mmap-numa bind memory mappings to randomly selected NUMA
nodes
--mmap-odirect enable O_DIRECT on file
--mmap-ops N stop after N mmap bogo operations
--mmap-osync enable O_SYNC on file
--mmap-slow-munmap munmap pages inefficiently one at a time
--mmap-stressful enable most stressful mmap options (and slowest)
--mmap-write-check set check value in each page and perform sanity
read check
--mmapaddr N start N workers stressing mmap with random
addresses
--mmapaddr-mlock attempt to mlock pages into memory
--mmapaddr-ops N stop after N mmapaddr bogo operations
--mmapcow N start N workers stressing copy-on-write and
munmaps
--mmapcow-fork force more page copying by regular process
forking
--mmapcow-free use madvise(MADV_FREE) on each page before
unmapping
--mmapcow-mlock lock copy-on-write page into memory before
unmapping
--mmapcow-numa bind memory mappings to randomly selected NUMA
nodes
--mmapcow-ops N stop after N mmapcow bogo operations
--mmapfiles N start N workers stressing many mmaps and munmaps
--mmapfiles-numa bind memory mappings to randomly selected NUMA
nodes
--mmapfiles-ops N stop after N mmapfiles bogo operations
--mmapfiles-populate populate memory mappings
--mmapfiles-shared enable shared mappings instead of private
mappings
--mmapfixed N start N workers stressing mmap with fixed
mappings
--mmapfixed-mlock attempt to mlock pages into memory
--mmapfixed-numa bind memory mappings to randomly selected NUMA
nodes
--mmapfixed-ops N stop after N mmapfixed bogo operations
--mmapfork N start N workers stressing many forked
mmaps/munmaps
--mmapfork-bytes N mmap and munmap N bytes by workers for each
stress iteration
--mmapfork-ops N stop after N mmapfork bogo operations
--mmapfork-procs N specify number of processes per instance
--mmaphuge N start N workers stressing mmap with huge mappings
--mmaphuge-file perform mappings on a temporary file
--mmaphuge-mlock attempt to mlock pages into memory
--mmaphuge-mmaps N select number of memory mappings per iteration
--mmaphuge-numa bind memory mappings to randomly selected NUMA
nodes
--mmaphuge-ops N stop after N mmaphuge bogo operations
--mmapmany N start N workers stressing many mmaps and munmaps
--mmapmany-mlock attempt to mlock pages into memory
--mmapmany-numa bind memory mappings to randomly selected NUMA
nodes
--mmapmany-ops N stop after N mmapmany bogo operations
--mmapmany-mappings N perfor N mmap mappings
--mmaprandom N start N workers stressing random memory mapping
operations
--mmaprandom-mappings N maximum number of mappings to be made
--mmaprandom-numa move processes to randomly chosen NUMA nodes
--mmaprandom-ops N stop after N mmaprandom bogo operations
--mmaptorture N start N workers torturing page mappings
--mmaptorture-bytes N size of file backed region to be memory mapped
--mmaptorture-msync N percentage of pages to be msync'd (default 10%)
--mmaptorture-ops N stop after N mmaptorture bogo operations
--module N start N workers performing module requests
--module-name F use the specified module name F to load.
--module-no-unload skip unload of the module after module load
--module-no-modver ignore symbol version hashes
--module-no-vermag ignore kernel version magic
--module-ops N stop after N module bogo operations
--monte-carlo N start N workers performing monte-carlo
computations
--monte-carlo-method M select computation method [ pi | e | exp | sin |
sqrt | squircle ]
--monte-carlo-ops N stop after N monte-carlo operations
--monte-carlo-rand R select random number generator [ all | drand48 |
getrandom | lcg | pcg32 | mwc32 | mwc64 | random |
xorshift ]
--monte-carlo-samples N specify number of samples for each computation
--mpfr N start N workers performing multi-precision
floating point operations
--mpfr-ops N stop after N multi-precision floating point
operations
--mpfr-precision N specific floating point precision as N bits
--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-bytes N mremap N bytes maximum for each stress iteration
--mremap-mlock mlock remap pages, force pages to be unswappable
--mremap-numa bind memory mappings to randomly selected NUMA
nodes
--mremap-ops N stop after N mremap bogo operations
--mseal N start N workers exercising sealing of mmap'd
memory
--mseal-ops N stop mseal workers after N bogo mseal operations
--msg N start N workers stressing System V messages
--msg-bytes N set the message size 4..8192
--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-bytes N size of file and memory mapped region to msync
--msync-ops N stop msync workers after N bogo msyncs
--msyncmany N start N workers stressing msync on many mapped
pages
--msyncmany-ops N stop after N msyncmany bogo operations
--mtx N start N workers exercising ISO C mutex operations
--mtx-ops N stop after N ISO C mutex bogo operations
--mtx-procs N select the number of concurrent processes
--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-affinity change CPU affinity randomly across locks
--mutex-ops N stop after N mutex bogo operations
--mutex-procs N select the number of concurrent processes
--nanosleep N start N workers performing short sleeps
--nanosleep-method M select nanosleep sleep time method [ all | cstate
| random ]
--nanosleep-ops N stop after N bogo sleep operations
--nanosleep-threads N number of threads to run concurrently (default 8)
--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-instr INSTR specify nop instruction to use
--nop-ops N stop after N nop bogo no-op operations
--null N exercising /dev/null with write, ioctl, lseek,
fcntl, fallocate and fdatasync
--null-ops N stop after N /dev/null bogo operations
--null-write just exercise /dev/null with writing
--numa N start N workers stressing NUMA interfaces
--numa-bytes N size of memory region to be exercised
--numa-ops N stop after N NUMA bogo operations
--numa-shuffle-addr shuffle page addresses to move to numa nodes
--numa-shuffle-node shuffle numa nodes on numa pages moves
--numacopy N start N workers copying pagess between NUMA nodes
--numacopy-affinity A select cpu affinity [ next | none | node | prev |
random ]
--numacopy-mode M select mbind mode flags [ bind | interleave |
preferred | weighted-interleave ]
--numacopy-ops N stop after N NUMA page copying 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-method M set opcode stress method (M = random, inc, mixed,
text)
--opcode-ops N stop after N opcode bogo operations
-o N, --open N start N workers exercising open/close
--open-fd open files in /proc/$pid/fd
--open-max N specify maximum number of files to open
--open-ops N stop after N open/close bogo operations
--ovpn N start N workers exercising ovpn tasks events
--ovpn-ops N stop ovpn workers after N bogo events
--ovpn-tunnel build a real two-endpoint DCO tunnel (two netns)
and exercise the data path
--pagemove N start N workers that shuffle move pages
--pagemove-bytes N size of mmap'd region to exercise page moving in
bytes
--pagemove-mlock attempt to mlock pages into memory
--pagemove-numa bind memory mappings to randomly selected NUMA
nodes
--pagemove-ops N stop after N page move bogo operations
--pagescatter N start N workers that allocate pages at random
addresses
--pagescatter-numa move pages to randomly chosen NUMA nodes
--pagescatter-ops N stop after N page operations
--pagescatter-order N log2 number of pages to use
--pagescatter-populate prefault pages during page mapping
--pageswap N start N workers that swap pages out and in
--pageswap-ops N stop after N page swap bogo operations
--pageswap-pages N specify maximum number of pages to swap out
--pci N start N workers that read and mmap PCI regions
--pci-dev name specify the pci device 'xxxx:xx:xx.x' to exercise
--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-mtrr enable modification of MTRR types on physical
page
--physpage-ops N stop after N physical page bogo operations
--physmmap N start N workers performing /dev/mem physical page
mmaps/munmaps
--physmmap-ops N stop after N /dev/mem physical page mmap/munmap
bogo operations
--physmmap-read read data from mapping
--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-max-size N specify maximum size of raw UDP data
--ping-sock-ops N stop after N ping sendto messages
--pinmem N start N workers pinning available memory
--pinmem-cycle cycle memory pinning/unpinning
--pimmem-method M memory pinning methid [ all | io-uring | madvise
| mlock
--pinmem-ops N stop after N memory pinning bogo operations
-p N, --pipe N start N workers exercising pipe I/O
--pipe-data-size N set pipe size of each pipe write to N bytes
--pipe-ops N stop after N pipe I/O bogo operations
--pipe-size N set pipe size to N bytes
--pipe-vmsplice use vmsplice for pipe data transfer
-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-procs N specify number of proxesses to per stressor
--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
--plugin N start N workers exercising random plugins
--plugin-method M set plugin stress method
--plugin-ops N stop after N plugin bogo operations
--plugin-so file specify plugin shared object file
-P N, --poll N start N workers exercising zero timeout polling
--poll-fds N use N file descriptors
--poll-ops N stop after N poll bogo operations
--poll-random-us N use random poll delays of 0..N-1 microseconds
--powmath N start N workers exercising power math functions
--powmath-method M select power math function to exercise
--powmath-ops N stop after N powmath bogo power math operations
--prctl N start N workers exercising prctl system call
--prctls-ops N stop prctl workers after N bogo prctl operations
--prefetch N start N workers exercising memory prefetching
--prefetch-l3-size N specify the L3 cache size of the CPU
--prefetch-method M specify the prefetch method
--prefetch-ops N stop after N bogo prefetching operations
--prime N start N workers that find prime numbers
--prime-method M method of searching for next prime [ factorial |
inc | pwr2 | pwr10 ]
--prime-ops N stop after N prime operations
--prime-progress show prime progress every 60 seconds (just first
stressor instance)
--prime-start N value N from where to start computing primes
--prio-inv start N workers exercising priority inversion
lock operations
--prio-inv-ops N stop after N priority inversion lock bogo
operations
--prio-inv-policy P select scheduler policy [ batch | ext | idle |
fifo | other | rr ]
--prio-inv-type T pthread priority type [ inherit | none | protect
]
--priv-instr N start N workers exercising privileged instruction
--priv-instr-ops N stop after N bogo instruction operations
--procfs N start N workers reading portions of /proc
--procfs-ops N stop procfs workers after N bogo read operations
-d N, --pseek N start N workers spinning on seek/write/seek/read
--pseek-io-size N set the default write/read I/O size to N bytes
--pseek-rand perform random seeks rather than fixed seeks
--pthread N start N workers that create multiple threads
--pthread-max P create P threads at a time by each worker
--pthread-ops N stop pthread workers after N bogo threads created
--ptrace N start N workers that trace a child using ptrace
--ptrace-ops N stop ptrace workers after N system calls are
traced
--ptr-chase N start N workers that chase pointers around many
nodes
--ptr-chase-ops N stop after N bogo pointer chase operations
--ptr-chase-pages N N is the number of pages for nodes of pointers
--pty N start N workers that exercise pseudoterminals
--pty-max N attempt to open a maximum of N ptys
--pty-ops N stop pty workers after N pty bogo operations
-Q N, --qsort N start N workers qsorting 32 bit random integers
--qsort-method M select qsort method [ qsort-libc | qsort_bm ]
--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
--race-sched N start N workers that race cpu affinity
--race-sched-method M select method of process moving [ all | rand |
next | prev | yoyo | randinc ]
--race-sched-ops N stop after N bogo race operations
--radixsort N start N workers radix sorting random strings
--radixsort-method M select sort method [ radixsort-libc |
radixsort-nonlibc]
--radixsort-ops N stop after N radixsort bogo operations
--radixsort-size N number of strings to sort
--ramfs N start N workers exercising ramfs mounts
--ramfs-fill attempt to fill ramfs
--ramfs-ops N stop after N bogo ramfs mount operations
--ramfs-size N set the ramfs size in bytes, e.g. 2M is 2MB
--randlist N start N workers that exercise random ordered list
--randlist-compact reduce mmap and malloc overheads
--randlist-items N number of items in the random ordered list
--randlist-ops N stop after N randlist bogo no-op operations
--randlist-size N size of data in each item in the list
--rawdev N start N workers that read a raw device
--rawdev-method M specify the rawdev read method to use
--rawdev-ops N stop after N rawdev read operations
--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
--rawpkt-rxring N setup raw packets with RX ring with N number of
blocks, this selects TPACKET_V3
--rawsock N start N workers performing raw socket
send/receives
--rawsock-ops N stop after N raw socket bogo operations
--rawsock-port P use socket P to P + number of workers - 1
--rawudp N start N workers exercising raw UDP socket I/O
--rawudp-if I use network interface I, e.g. lo, eth0, etc.
--rawudp-ops N stop after N raw socket UDP bogo operations
--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
--regex N start N workers exercise POSIX regular
expressions
--regex-ops N stop after N regular expression operations
--regs N start N workers exercising CPU generic registers
--regs-bitflip flip bits in registers to consume more power
--regs-ops N stop after N x 1000 rounds of register shuffling
--remap N start N workers exercising page remappings
--remap-mlock attempt to mlock pages into memory
--remap-ops N stop after N remapping bogo operations
--remap-pages N specify N pages to remap (N must be power of 2)
-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-mlock attempt to mlock pages into memory
--resources-num N number of resources to allocate per instance
--resources-ops N stop after N resource bogo operations
--resources-procs N number of child processes per instance
--revio N start N workers performing reverse I/O
--revio-bytes N specify file size (default is 1GB)
--revio-ops N stop after N revio bogo operations
--revio-opts list specify list of various stressor options
--ring-pipe N start N workers exercising a ring of pipes
--ring-pipe-num N number of pipes to use
--ring-pipe-ops N stop after N ring pipe I/O bogo operations
--ring-pipe-size N size of data to be written and read in bytes
--ring-pipe-splice use splice instead of read+write
--rlimit N start N workers that exercise rlimit
--rlimit-ops N stop after N rlimit bogo operations
--rmap N start N workers that stress reverse mappings
--rmap-ops N stop after N rmap bogo operations
--rmap-procs N specify number of child processes to spawn
--rofs N start N workers exercising read-only filesystem
--rofs-dir path specify mount point of read-only filesystem
--rofs-ops N stop after N rofs bogo operations
--rotate N start N workers performing rotate ops
--rotate-method M select rotate method M
--rotate-ops N stop after N rotate 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
--schedmix N start N workers that exercise a mix of scheduling
loads
--schedmix-cpumix randomly mix child processes to different CPUs
--schedmix-ops N stop after N schedmix bogo operations
--schedmix-procs N select number of schedmix child processes 1..64
--schedpolicy N start N workers that exercise scheduling policy
--schedpolicy-cpumix randomly mix schedpolicy processes to different
CPUs
--schedpolicy-ops N stop after N scheduling policy bogo operations
--schedpolicy-rand select scheduling policy randomly
--sctp N start N workers performing SCTP send/receives
--sctp-domain D specify sctp domain, default is ipv4
--sctp-if I use network interface I, e.g. lo, eth0, etc.
--sctp-max-size N specify maximum size of sctp data
--sctp-ops N stop after N SCTP bogo operations
--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-shared share the semaphore across all semaphore
stressors
--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
--sem-sysv-setall exercise semctl SETALL (will alter the processes'
semaphore set)
--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
--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-bytes N allocate/free N bytes of POSIX shared memory
--shm-mlock attempt to mlock pages into memory
--shm-objs N allocate N POSIX shared memory objects per
iteration
--shm-ops N stop after N POSIX shared memory bogo operations
--shm-sysv N start N workers that exercise System V shared
memory
--shm-sysv-bytes N allocate and free N bytes of shared memory per
loop
--shm-sysv-mlock attempt to mlock pages into memory
--shm-sysv-ops N stop after N shared memory bogo operations
--shm-sysv-segs N allocate N shared memory segments per iteration
--sigabrt N start N workers generating SIGABRT signals
--sigabrt-ops N stop after N bogo SIGABRT operations
--sigbus N start N workers generating bus faults
--sigbus-ops N stop after N bogo bus 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
--sighup N start N workers generating SIGHUP signals
--sighup-ops N stop after N bogo SIGHUP operations
--sigio N start N workers that exercise SIGIO signals
--sigio-ops N stop after N bogo sigio signals
--sigill N start N workers generating SIGILL signals
--sigill-ops N stop after N SIGILL 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
--sigstop N start N workers sending SIGSTOP signals
--sigstop-ops N stop after N kill SIGSTOP and SIGKILL bogo
operations
--sigsuspend N start N workers exercising sigsuspend
--sigsuspend-ops N stop after N bogo sigsuspend wakes
--sigtrap N start N workers generating SIGTRAP signals
--sigtrap-ops N stop after N bogo SIGTRAP operations
--sigurg N start N workers exercising SIGURG on MSB_OOB
socket sends
--sigurg-ops N stop after N SIGURG signals
--sigvtalrm N start N workers exercising SIGVTALRM signals
--sigvtalrm-ops N stop after N SIGVTALRM signals
--sigxcpu N start N workers that exercise SIGXCPU signals
--sigxcpu-ops N stop after N bogo SIGXCPU signals
--sigxfsz N start N workers that exercise SIGXFSZ signals
--sigxfsz-ops N stop after N bogo SIGXFSZ signals
--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-affinity change CPU affinity before each sleep
--sleep-max P create P threads at a time by each worker
--sleep-ops N stop after N bogo sleep operations
--sleepstorm N start N workers that run pthreads that sleep and
wake synchronously
--sleepstorm-cpumix randomly mix threads to different CPUs
--sleepstorm-ops N stop pthread workers after N bogo threads created
--sleepstorm-pthreads N specify number of concurrent pthreads per
stressor instance
--sleepstorm-sleep-ms N specify sleep time in milliseconds
--sleepstorm-yield M select yielding method [ always | never | random
]
--smi N start N workers that trigger SMIs
--smi-ops N stop after N SMIs have been triggered
--snd-pcm N start N workers exercising ioctls on /dev/snd pcm
drivers
--snd-pcm-ops N stop after N pcm bogo itctl operations
--snd-timer N start N workers exercise the /dev/snd tiner
--snd-timer-ops N stop after N timer events
-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-msgs N number of messages to send per connection
--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
--sockabuse-port P use socket ports P to P + number of workers - 1
--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
--sockfd-reuse reuse file descriptors between sender and
receiver
--sockmany N start N workers exercising many socket
connections
--sockmany-if I use network interface I, e.g. lo, eth0, etc.
--sockmany-max-size N specify maximum size of sockmany data
--sockmany-ops N stop after N sockmany bogo operations
--sockmany-port use socket ports P to P + number of workers - 1
--sockpair N start N workers exercising socket pair I/O
activity
--sockpair-max-size N specify maximum size of socket pair data
--sockpair-ops N stop after N socket pair bogo operations
--softlockup N start N workers that cause softlockups
--softlockup-ops N stop after N softlockup bogo operations
--sparsematrix N start N workers that exercise a sparse matrix
--sparsematrix-items N N is the number of items in the spare matrix
--sparsematrix-method M select storage method: all, hash, hashjudy, judy,
list, mmap, qhash, rb, splay
--sparsematrix-ops N stop after N bogo sparse matrix operations
--sparsematrix-size N M is the width and height X x Y of the matrix
--spawn N start N workers spawning stress-ng using
posix_spawn
--spawn-ops N stop after N spawn bogo operations
--spec-rollback N start N workers exercising speculation rollbacks
--spec-rollback-ops N stop after N speculation rollback bogo operations
--spec-rollback-size N number of items in speculation read buffer
--spinmem start N workers exercising shared memory spin
write/read operations
--spinmem-affinity use CPU affinity (specific CPUS can be defined by
--taskset option)
--spinmem-method select method of write/reads, default is 32bit
--spinmem-numa move pages to randomly chosen NUMA nodes
--spinmem-ops stop after N bogo shared memory spin write/read
operations
--spinmem-yield force scheduling yields after each spin
write/read operation
--splice N start N workers reading/writing using splice
--splice-bytes N number of bytes to transfer per splice call
--splice-ops N stop after N bogo splice operations
--stack N start N workers generating stack overflows
--stack-fill fill stack, touches all new pages
--stack-mlock mlock stack, force pages to be unswappable
--stack-ops N stop after N bogo stack overflows
--stack-pageout use madvise to try to swap out stack
--stack-unmap unmap a page in the stack on each iteration
--stackmmap N start N workers exercising a filebacked stack
--stackmmap-ops N stop after N bogo stackmmap operations
--statmount N start N workers exercising statmount and
listmount
--statmount-ops N stop after N bogo statmount and listmount
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-discontiguous make mmap'd physical pages discontiguous
--stream-index N 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
--stream-mlock attempt to mlock pages into memory
--stream-prefetch use prefetching (where available)
--stream-ops N stop after N bogo stream operations
--strnum N start N workers string/numeric conversions
--strnum-method M select the string/numeric conversion method to
operate with
--strnum-ops N stop after N string/numeric bogo operations
--swap N start N workers exercising swapon/swapoff
--swap-ops N stop after N swapon/swapoff operations
--swap-self attempt to swap stressors pages out
-s N, --switch N start N workers doing rapid context switches
--switch-freq N set frequency of context switches
--switch-method M mq | pipe | sem-sysv
--switch-ops N stop after N context switch bogo operations
--symlink N start N workers creating symbolic links
--symlink-ops N stop after N symbolic link bogo operations
--symlink-sync enable sync'ing after symlinking/unsymlinking
--sync-file N start N workers exercise sync_file_range
--sync-file-bytes N size of file to be sync'd
--sync-file-ops N stop after N sync_file_range bogo operations
--syncload N start N workers that synchronize load spikes
--syncload-msbusy M maximum busy duration in milliseconds
--syncload-mssleep M maximum sleep duration in milliseconds
--syncload-ops N stop after N syncload bogo operations
--sysbadaddr N start N workers that pass bad addresses to
syscalls
--sysbadaddr-ops N stop after N sysbadaddr bogo syscalls
--syscall N start N workers that exercise a wide range of
system calls
--syscall-method M select method of selecting system calls to
exercise
--syscall-ops N stop after N syscall bogo operations
--syscall-rank R select ranking of system call stats [ name |
average | min | max ]
--syscall-top N display fastest top N system calls
--sysfs N start N workers reading files from /sys
--sysfs-ops N stop after sysfs bogo operations
--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
--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-freq F run timer(s) at F Hz, range 1 to 1000000000
--timer-ops N stop after N timer bogo events
--timer-rand enable random timer frequency
--timerfd N start N workers producing timerfd 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-ops N stop after N timerfd bogo events
--timerfd-rand enable random timerfd frequency
--timermix N start N workers producing a mix of timer events
--timermix-ops N stop after N timer bogo events
--time-warp N start N workers checking for timer/clock warping
--time-warp-ops N stop workers after N bogo timer/clock reads
--tlb-numa N start N workers that force TLB shootdowns on NUMA
systems
--tlb-numa-entries N select number of TLB page entries per instance to
use (default 512)
--tlb-nuna-nombind disable setting NUMA policy on pages
--tlb-nuna-nopageout disable paging out randomly selected pages
--tlb-numa-ops N stop after N TLB shootdown bogo ops
--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-mmap-async using asynchronous msyncs for tmpfs file based
mmap
--tmpfs-mmap-file mmap onto a tmpfs file using synchronous msyncs
--tmpfs-ops N stop after N tmpfs bogo ops
--touch N start N stressors that touch and remove files
--touch-method M specify method to touch the file, open | create
--touch-ops N stop after N touch bogo operations
--touch-opts list touch open options all, direct, dsync, excl,
noatime, sync, trunc
--tree N start N workers that exercise tree structures
--tree-method M select tree method [ all | avl | binary | btree |
rb | splay | treap ]
--tree-ops N stop after N bogo tree operations
--tree-size N N is the number of items in the tree
--trig N start N workers exercising trigonometric
functions
--trig-method M select trigonometric function to exercise
--trig-ops N stop after N trig bogo trigonometric operations
--tsc N start N workers reading the time stamp counter
--tsc-lfence add lfence after TSC reads for serialization (x86
only)
--tsc-ops N stop after N TSC bogo operations
--tsc-rdscp use rdtscp instead of rdtsc, disables tsc-lfence
(x86 only)
--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-port P use ports P to P + number of workers - 1
--tun-tap use TAP interface instead of TUN
--udp N start N workers performing UDP send/receives
--udp-domain D specify domain, default is ipv4
--udp-gro enable UDP-GRO
--udp-if I use network interface I, e.g. lo, eth0, etc.
--udp-lite use the UDP-Lite (RFC 3828) protocol
--udp-max-size N specify maximum size of UDP data
--udp-ops N stop after N udp bogo operations
--udp-port P use ports P to P + number of workers - 1
--udp-flood N start N workers that performs a UDP flood attack
--udp-flood-domain D specify domain, default is ipv4
--udp-flood-if I use network interface I, e.g. lo, eth0, etc.
--udp-flood-max-size N specify maximum size of UDP data
--udp-flood-ops N stop after N udp flood bogo operations
--umask N start N workers exercising umask, file
create/stat/close/unlink
--umask-ops N stop after N umask and file operations
--umount N start N workers exercising umount races
--umount-ops N stop after N bogo umount operations
--unlink N start N unlink exercising stressors
--unlink-ops N stop after N unlink exercising bogo operations
--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-bytes N size of mmap'd region to fault on
--userfaultfd-ops N stop after N page faults have been handled
--usersyscall N start N workers exercising a userspace system
call handler
--usersyscall-ops N stop after N successful SIGSYS system calls
--utime N start N workers updating file timestamps
--utime-fsync force utime meta data sync to the file system
--utime-ops N stop after N utime bogo operations
--v4l2 N start N workers
--v4l2-ops N stop after N bogo operations
--varyload N start N workers that exercise a mix of scheduling
loads
--varyload-method M select a varyload method, default is all
--varyload-ms M vary workload every M milliseconds
--varyload-ops N stop after N varyload bogo operations
--varyload-sched P select scheduler policy [ batch | deadline | ext
| fifo | idle | rr | other ]
--varyload-type T select a varyload load type [ brown | saw-inc |
saw-dec | triangle | pulse | random ]
--vdso N start N workers exercising functions in the VDSO
--vdso-func F use just vDSO function F
--vdso-ops N stop after N vDSO function calls
--veccmp N start N workers performing integer vector
comparison ops
--veccmp-ops N stop after N integer vector comparison bogo
operations
--vecfp N start N workers performing vector math ops
--vecfp-method M select floating point vector method
--vecfp-ops N stop after N vector math bogo operations
--vecmath N start N workers performing vector math ops
--vecmath-ops N stop after N vector math bogo operations
--vecshuf N start N workers performing vector shuffle ops
--vecshuf-method M select vector shuffling method
--vecshuf-ops N stop after N vector shuffle 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 vforked processes per iteration, default
is 1
--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
--vforkmany-vm-bytes set the default vm mmap'd size, default 64MB
-m N, --vm N start N workers spinning on anonymous mmap
--vm-bytes N allocate N bytes in total across vm workers
(default 256MB)
--vm-discontiguous make mmap'd physical pages discontiguous
--vm-flush cache flush data after write
--vm-hang N sleep N seconds before freeing memory
--vm-keep redirty memory instead of reallocating
--vm-locked lock the pages of the mapped region into memory
--vm-madvise M specify mmap'd vm buffer madvise advice
--vm-method M specify stress vm method M, default is all
--vm-nt where possible use hinted non-temporal stores
--vm-numa bind memory mappings to randomly selected NUMA
nodes
--vm-ops N stop after N vm bogo operations
--vm-populate populate (prefault) page tables for a mapping
--vma N start N workers that exercise kernel VMA
structures
--vma-ops N stop N workers after N mmap VMA operations
--vm-addr N start N vm address exercising workers
--vm-addr-method M select method to exercise vm addresses
--vm-addr-mlock attempt to mlock pages into memory
--vm-addr-numa bind memory mappings to randomly selected NUMA
nodes
--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-bytes N number of bytes to transfer per vmsplice call
--vm-splice-ops N stop after N bogo splice operations
--vnni N start N workers performing vector neural network
ops
--vnni-intrinsic use x86 intrinsic vnni methods, disable generic
methods
--vnni-method M specify specific vnni methods to exercise
--vnni-ops N stop after N vnni bogo operations
--wait N start N workers waiting on child being
stop/resumed
--wait-ops N stop after N bogo wait operations
--waitcpu N start N workers exercising wait/pause/nop
instructions
--waitcpu-ops N stop after N wait/pause/nop bogo 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
--workload N start N workers that exercise a mix of scheduling
loads
--workload-dist type workload distribution type [random1 | random2 |
random3 | cluster]
--workload-load P percentage load P per workload time slice
--workload-method M select a workload method, default is all
--workload-ops N stop after N workload bogo operations
--workload-quanta-us N max duration of each quanta work item in
microseconds
--workload-sched P select scheduler policy [ batch | deadline | ext
| idle | fifo | rr | other ]
--workload-slice-us N duration of workload time load in microseconds
--workload-threads N number of workload threads workers to use,
default is 0 (disabled)
--x86cpuid N start N workers exercising the x86 cpuid
instruction
--x86cpuid-ops N stop after N cpuid bogo operations
--x86syscall N start N workers exercising functions using
syscall
--x86syscall-func F use just syscall function F
--x86syscall-ops N stop after N syscall function calls
--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
--yield-procs N specify number of yield processes per stressor
--yield-sched P select scheduler policy [idle, fifo, rr, other,
batch, deadline]
--zero N start N workers exercising /dev/zero with read,
mmap, ioctl, lseek
--zero-ops N stop after N /dev/zero bogo read operations
--zero-read just exercise /dev/zero with reading
--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-clone using clone instead of fork, exercise clone and
network cleanup
--zombie-max N set upper limit of N zombies per worker
--zombie-ops N stop after N bogo zombie fork operations
example: stress-ng --cpu 8 --iomix 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
Options (635)
| Option | Description | Source |
|---|---|---|
--abort | this option will force all running stressors to abort (terminate) if any other stressor terminates prematurely because of a failure. | help + man |
--aggressive, -A | enables more swap, cache and memory aggressive options as well as forcing CPU affinity changes and maximizing CPU speed. | help + man |
--autogroup | with this option any successful nice(2) call will attempt to also set the /proc/self/autogroup setting to the niceness level of the calling process. | help + man |
-a, --all N | start N instances of all stressors in parallel. | help + man |
-b, --backoff N | wait N microseconds between the start of each stress worker process. | help + man |
--buddystat S | every S seconds show buddy allocator free memory sizes and percentage estimation of fragmentation for memory regions zones. | help + man |
--buildinfo | report build information such as build date and time, compiler used, compilation and linker flags, standard C version used. | help + man |
--c-states | report CPU C-state residencies. | help + man |
--change-cpu | this forces child processes of some stressors to change to a different CPU from the parent on startup. | help + man |
--class name | specify a class of stressors, use with | help + man |
--compact-memory | compact memory at the start of each stressor invocation to reduce memory fragmentation, requires root capability (Linux only). | help + man |
--config | print out the configuration used to build stress-ng. | help + man |
--dentrystat S | every S seconds show number of allocated directory entries, number of negative directory entries in use and pages requested. | help + man |
-n, --dry-run | parse options, but do not run stress tests. | help + man |
--drop-caches | drop the page cache, inode and dentry caches before each stressor instance is invoked (Linux only, needs root privilege). | help + man |
--exercised | show the features, libraries and system calls exercised by the core of each stressor | help + man |
--ftrace | enable kernel function call tracing (Linux only). | help + man |
-h, --help | --help show help | help + man |
--ignite-cpu | alter kernel controls to try and maximize the CPU. | help + man |
--interrupts | check for any system management interrupts or error interrupts that occur, for example thermal overruns, machine check exceptions, etc. | help + man |
--ionice-class C | specify ionice class (idle, besteffort, realtime) | help + man |
--ionice-level L | specify ionice level (only on Linux). | help + man |
--ios | report I/O average read/write rates (Linux only) | help + man |
-I, --iostat S | every S seconds show I/O statistics on the device that stores the stress-ng temporary files. | help + man |
-j, --job jobfile | --job jobfile run the named jobfile | help + man |
--keep-files | do not remove files and directories created by the stressors. | help + man |
-k, --keep-name | by default, stress-ng will attempt to change the name of the stress processes according to their functionality; | help + man |
-K, --klog-check | check the kernel log for kernel error and warning messages and report these as soon as they are detected. | help + man |
--ksm | enable kernel samepage merging (Linux only). | help + man |
--limit-as N | set the stressor process's maximum size of the virtual memory (address space), see rlimit(2) RLIMIT_AS. | help + man |
--limit-data N | set the stressor process's maximum size of the data segment (initialized data, uninitialized data, and heap), see rlimit(2) RLIMIT_DATA. | help + man |
--limit-stack N | set the stressor process's maximum size of the stack, see rlimit(2) RLIMIT_STACK. | help + man |
--log-brief | by default stress-ng will report the name of the program, the message type and the process id as a prefix to all output. | help + man |
-L, --log-file filename | write messages to the specified log file, this does not replace the output from stdout, but creates a logged copy of it in the specified file. | help + man |
--log-lockless | log messages use a lock to avoid intermingling of blocks of stressor messages, however this may cause contention when emitting a high rate of logging messages in verbose mode with many stressors are… | help + man |
--make-it-fail | enable fault injection on stressor processes (Linux only, needs to run with root permission to write to /proc/self/make-it-fail). | help + man |
--maximize | overrides the default stressor settings and instead sets these to the maximum settings allowed. | help + man |
--max-fd N | set the maximum limit on file descriptors (value or a % of system allowed maximum). | help + man |
--mbind list | set strict NUMA memory allocation based on the list of NUMA nodes provided; | help + man |
-M, --metrics | output number of bogo operations in total performed by the stress processes. | help + man |
--metrics-brief | show a shorter list of stressor metrics (no CPU used per instance). | help + man |
--minimize | overrides the default stressor settings and instead sets these to the minimum settings allowed. | help + man |
--no-madvise | from version 0.02.26 stress-ng automatically calls madvise(2) with random madvise advice options before each mmap(2) and munmap(2) call to stress the vm subsystem a little harder. | help + man |
--no-madvise-opts list | specify one or more madvise(2) advice options to not use. | help + man |
--no-oom-adjust | disable any form of out-of-memory score adjustments, keep the system defaults. | help + man |
--no-rand-seed | Do not seed the stress-ng pseudo-random number generator with a quasi random start seed, but instead seed it with constant values. | help + man |
--oom-avoid | Attempt to avoid out-of-memory conditions that can lead to the Out-of-Memory (OOM) killer terminating stressors. | help + man |
--oom-avoid-bytes N | Specify a low memory threshold to avoid making any further memory allocations. | help + man |
--oom-no-child | Disable running stressor as a child process with a parent that checks for Out-of-Memory (OOM) issues. | help + man |
--oomable, -O | Do not respawn a stressor if it gets killed by the Out-of-Memory (OOM) killer. | help + man |
--page-in | touch allocated pages that are not in core, forcing them to be paged back in. | help + man |
--parallel N | synonym for 'all N' | help |
--pathological | enable stressors that are known to hang a machine | help + man |
--pause N | pause N seconds between each stressor start | help + man |
--perf | measure processor and system activity using perf events. | help + man |
--permute N | run all permutations of the selected stressors with N instances of the permutated stressors per run. | help + man |
--progress | display the run progress when running stressors with the --sequential option. | help + man |
-q, --quiet | do not show any output. | help + man |
-r, --random N | --random N start N random workers | help + man |
--randprocname | enable random stressor process name generation. | help + man |
--rapl | Report the Running Average Power Limit (RAPL) energy measurements of stressor instances. | help + man |
--raplstat S | show RAPL power domain stats every S seconds (Linux x86 only) | help + man |
--resctrl list | specify resource control cache partitioning | help |
--sched type | select the named scheduler (only on Linux). | help + man |
--sched-prio N | select the scheduler priority level (only on Linux). | help + man |
--sched-period N | select the period parameter for deadline scheduler (only on Linux). | help + man |
--sched-runtime N | select the runtime parameter for deadline scheduler (only on Linux). | help + man |
--sched-deadline N | select the deadline parameter for deadline scheduler (only on Linux). | help + man |
--sched-reclaim | use CPU bandwidth reclaim feature for deadline scheduler (only on Linux). | help + man |
--seed N | set the random number to generate a seed with a 64 bit value. | help + man |
--settings | show the various option settings. | help + man |
--sequential N | sequentially run all the stressors one by one for a default of 60 seconds. | help + man |
--skip-silent | silence messages that report that a stressor has been skipped because it requires features not supported by the system, such as unimplemented system calls, missing resources or processor specific… | help + man |
--smart | scan the block devices for changes S.M.A.R.T. | help + man |
--sn | use scientific notation (e.g. 2.412e+01) for metrics. | help + man |
--status S | report every N seconds the number of running, exiting, reaped and failed stressors, number of stressors that received SIGARLM termination signal as well as the current run duration. | help + man |
--stderr | write messages to stderr. | help + man |
--stdout | all output to stdout (now the default) | help + man |
--stressor-time | (requires -v flag) log as debug the start and finish run times of each stressor instance, logged in the format: stressor [start|finish] HR:MN:SS.HS YYYY:MM:DD where HR is hours, MN is minutes, SS is… | help + man |
--stressors | output the names of the available stressors. | help + man |
--syslog | log output (except for verbose -v messages) to the syslog. | help + man |
--taskset list | set CPU affinity based on the list of CPUs provided; | help + man |
--temp-path path | specify a path for stress-ng temporary directories and temporary files; | help + man |
--thermalstat S | every S seconds show CPU and thermal load statistics. | help + man |
--thrash | This can only be used when running on Linux and with root privilege. | help + man |
-t, --timeout N | run each stress test for at least T seconds. | help + man |
--timer-slack N | adjust the per process timer slack to N nanoseconds (Linux only). | help + man |
--times | show the cumulative user and system times of all the child processes at the end of the stress run. | help + man |
--timestamp | add a timestamp in hours, minutes, seconds and hundredths of a second to the log output. | help + man |
--tz | collect temperatures from the available thermal zones on the machine (Linux only). | help + man |
-v, --verbose | show all debug, warnings and normal information output. | help + man |
--verify | verify results (not available on all tests) | help + man |
--verifiable | print the names of stressors that can be verified with the --verify option. | help + man |
-V, --version | show version of stress-ng, version of toolchain used to build stress-ng and system information. | help + man |
--vmstat S | every S seconds show statistics about processes, memory, paging, block I/O, interrupts, context switches, disks and CPU activity. | help + man |
--vmstat-units U | vmstat memory units, one of k | m | g | t | p | e | help |
-w, --with list | specify stressors to run when using the --all, --seq or --permute options. | help + man |
-x, --exclude list | specify a list of one or more stressors to exclude (that is, do not run them). | help + man |
-Y, --yaml filename | output gathered statistics to a YAML formatted file named filename'. | help + man |
--access N | start N workers that work through various settings of file mode bits (read, write, execute) for the file owner and check if the user permissions of the file using access(2) and faccessat(2) are sane. | help + man |
--access-ops N | stop access workers after N bogo access sanity checks. | help + man |
--acl N | start N workers that exercise permutations of ACL access permission settings on user, group and other tags. | help + man |
--acl-rand | randomize (by shuffling) the order of the ACL access permissions before exercising ACLs. | help + man |
--acl-ops N | stop acl workers after N bogo acl settings have been set. | help + man |
--acct N | start N workers that exercise the acct(2) accounting interface. | help + man |
--acct-ops N | stop after reading N process exiting accounting records | help + man |
--af-alg N | start N workers that exercise the AF_ALG socket domain by hashing and encrypting various sized random messages. | help + man |
--af-alg-dump | dump the internal list representing cryptographic algorithms parsed from the /proc/crypto file to standard output (stdout). | help + man |
--af-alg-ops N | stop af-alg workers after N AF_ALG messages are hashed. | help + man |
--af-alg-type type | crypto type [ all | ahash | shash | skcipher | rng | aead ] | help |
--affinity N | start N workers that run 16 processes that rapidly change CPU affinity (for systems that provide sched_setaffinity(2)). | help + man |
--affinity-delay D | delay for N nanoseconds before changing affinity to the next CPU. | help + man |
--affinity-ops N | stop affinity workers after N bogo affinity operations. | help + man |
--affinity-pin | pin all the 16 per stressor processes to a CPU. | help + man |
--affinity-procs N | specify number of processes per affinity instance to run, the range is 2 to 1024 with a default of 16. | help + man |
--affinity-rand | switch CPU affinity randomly rather than the default of sequentially. | help + man |
--affinity-sleep N | sleep for N nanoseconds before changing affinity to the next CPU. | help + man |
--aio N | start N workers that issue multiple small asynchronous I/O writes and reads on a relatively small temporary file using the POSIX aio interface. | help + man |
--aio-ops N | stop POSIX asynchronous I/O workers after N bogo asynchronous I/O requests. | help + man |
--aio-requests N | specify the number of POSIX asynchronous I/O requests each worker should issue, the default is 16; | help + man |
--aiol N | start N workers that issue multiple 4 K random asynchronous I/O writes using the Linux aio system calls io_setup(2), io_submit(2), io_getevents(2) and io_destroy(2). | help + man |
--aiol-ops N | stop Linux asynchronous I/O workers after N bogo asynchronous I/O requests. | help + man |
--aiol-requests N | specify the number of Linux asynchronous I/O requests each worker should issue, the default is 16; | help + man |
--alarm N | start N workers that exercise alarm(2) with MAXINT, 0 and random alarm and sleep delays that get prematurely interrupted. | help + man |
--alarm-ops N | stop after N alarm bogo operations. | help + man |
--apparmor N | start N workers that exercise various parts of the AppArmor interface. | help + man |
--apparmor-ops N | stop the AppArmor workers after N bogo operations. | help + man |
--atomic N | start N workers that exercise various GCC __atomic_() built in operations on 8, 16, 32 and 64 bit integers that are shared among the N workers. | help + man |
--atomic-ops N | stop the atomic workers after N bogo atomic operations. | help + man |
--bad-altstack N | start N workers that create broken alternative signal stacks for SIGSEGV and SIGBUS handling that in turn create secondary SIGSEGV/SIGBUS errors. | help + man |
--bad-altstack-ops N | stop the bad alternative stack stressors after N SIGSEGV bogo operations. | help + man |
--bad-ioctl N | start N workers that perform a range of illegal bad read ioctl(2) calls (using _IOR) and write ioctls (using _IOR with PROT_NONE mapped pages) across the device drivers. | help + man |
--bad-ioctl-alldev | exercise all devices (rather than just /dev/devname0 | help + man |
--bad-ioctl-method M | method of selecting ioctl command [ random | inc | random-inc | stride ] | help |
--bad-ioctl-ops N | stop the bad ioctl stressors after N bogo ioctl operations. | help + man |
--besselmath N | start N workers that exercise various Bessel functions. | help + man |
--besselmath-method M | select bessel math function to exercise | help + man |
--besselmath-ops N | stop after N besselmath bogo bessel math operations | help + man |
-B, --bigheap N | start N workers that grow their heaps by reallocating memory. | help + man |
--bigheap-bytes N | maximum heap growth as N bytes per bigheap worker. | help + man |
--bigheap-growth N | specify the amount of memory to grow heap by per iteration. | help + man |
--bigheap-mlock | attempt to mlock(2) future allocated pages into memory causing more memory pressure. | help + man |
--bigheap-ops N | stop the big heap workers after N bogo allocation operations are completed. | help + man |
--binderfs N | start N workers that mount, exercise and unmount binderfs. | help + man |
--binderfs-ops N | stop after N bogo binderfs operations | help + man |
--bind-mount N | start N workers that repeatedly bind mount /bin to a temporary path. | help + man |
--bind-mount-ops N | stop after N bind mount bogo operations. | help + man |
--bitonicsort N | start N workers that sort 32 bit integers using bitonic sort. | help + man |
--bitonicsort-ops N | stop bitonic sort stress workers after N bogo bitonic sorts. | help + man |
--bitonicsort-size N | specify number of 32 bit integers to sort, default is 262144 (256 × 1024). | help + man |
--bitops N | start N workers that perform various calculations using 32 bit integer manipulation operations. | help + man |
--bitops-method M | specify stress bitops method M, default is all | help + man |
--bitops-ops N | stop after N bitops bogo operations | help + man |
--bpf N | start N workers that generates BPF instructions for the bpf(2) system call to verify and JIT. | help + man |
--bpf-max N | specify the maximum number of BPF instructions to generate for the BPF code, minimum is 2, maximum is 1048576. | help + man |
--bpf-ops N | stop after N bpf(2) system calls. | help + man |
--branch N | start N workers that randomly branch to 1024 randomly selected locations and hence exercise the CPU branch prediction logic. | help + man |
--branch-jumps N | number of branches [ 64 | 128 | 256 | 512 | 1024 | 2048 | help |
--branch-ops N | stop the branch stressors after N × 1024 branches | help + man |
--brk N | start N workers that grow the data segment by one page at a time using multiple brk(2) calls. | help + man |
--brk-bytes N | maximum brk growth as N bytes per brk worker. | help + man |
--brk-mlock | attempt to mlock(2) future brk pages into memory causing more memory pressure. | help + man |
--brk-notouch | do not touch each newly allocated data segment page. | help + man |
--brk-ops N | stop the brk workers after N bogo brk operations. | help + man |
--bsearch N | start N workers that binary search a sorted array of 32 bit integers using bsearch(3). | help + man |
--bsearch-method M | select bsearch method [ bsearch-libc | bsearch-nonlibc ] | help |
--bsearch-ops N | stop the bsearch worker after N bogo bsearch operations are completed. | help + man |
--bsearch-size N | specify the size (number of 32 bit integers) in the array to bsearch. | help + man |
--bubblesort N | start N workers that sort 32 bit integers using bubblesort. | help + man |
--bubblesort-method M | select sort method [ bubblesort-fast | bubblesort-naive | help |
--bubblesort-ops N | stop bubblesort stress workers after N bogo bubblesorts. | help + man |
--bubblesort-size N | specify number of 32 bit integers to sort, default is 16384. | help + man |
-C, --cache N | start N workers that perform random wide spread memory read and writes to thrash the CPU cache. | help + man |
--cache-badpage | periodically cache flush on an unmapped (bad) page | help + man |
--cache-cldemote | cache line demote (x86 only). | help + man |
--cache-clflushopt | use optimized cache line flush (x86 only). | help + man |
--cache-clwb | cache line writeback (x86 / RISC-V) | help + man |
--cache-enable-all | where appropriate exercise the cache using cldemote, clflushopt, fence, flush, sfence and prefetch. | help + man |
--cache-fence | force write serialization on each store operation (x86 only). | help + man |
--cache-flush | force flush cache on each store operation (x86 only). | help + man |
--cache-level N | specify level of cache to exercise (1 = L1 cache, 2 = L2 cache, 3 = L3/LLC cache (the default)). | help + man |
--cache-no-affinity | do not change processor affinity when --cache is in effect. | help + man |
--cache-ops N | stop cache thrash workers after N bogo cache thrash operations. | help + man |
--cache-permute | permute the selected cache flags when exercising cache for an improved mix of cache operations. | help + man |
--cache-prefetch | force read prefetch on read address on architectures that support prefetching. | help + man |
--cache-prefetchw | force a redundant write prefetch on architectures that support write prefetching. | help + man |
--cache-sfence | force write serialization on each store operation using the sfence instruction (x86 only). | help + man |
--cache-size N | override the default cache size setting to N bytes. | help + man |
--cache-ways N | specify the number of cache ways to exercise. | help + man |
--cachehammer N | start N workers that exercise the cache with a randomized mix of memory read/writes and where possible cache prefetches and cache flushes to random addresses in three memory mapped regions, one of… | help + man |
--cachehammer-method | select hammering method [ permute | random ] | help |
--cachehammer-numa | periodically assign exercised pages to randomly selected NUMA nodes. | help + man |
--cachehammer-ops N | stop after N cache hammer operations. | help + man |
--cacheline N | start N workers that exercise reading and writing individual bytes in a shared buffer that is the size of a cache line. | help + man |
--cacheline-affinity | frequently change CPU affinity, spread cacheline processes evenly across all online CPUs to try and maximize lower-level cache activity. | help + man |
--cacheline-method M | specify a cacheline stress method. | help + man |
--cacheline-ops N | stop cacheline workers after N loops of the byte exercising in a cacheline. | help + man |
--cap N | start N workers that exercise per process capabilities via calls to capget(2) and capset(2), (Linux only). | help + man |
--cap-ops N | stop cap workers after N bogo capget/capset operations | help + man |
--cgroup N | start N workers that mount a cgroup, move a child to the cgroup, read, write and remove the child from the cgroup and umount the cgroup per bogo-op iteration. | help + man |
--cgroup-ops N | stop after N iterations of cgroup actions | help + man |
--chattr N | start N workers that attempt to exercise file attributes via the EXT2_IOC_SETFLAGS ioctl(2). | help + man |
--chattr-ops N | stop chattr workers after N bogo operations | help + man |
--chdir N | start N workers that change directory between directories using chdir(2). | help + man |
--chdir-dirs N | select number of directories to exercise chdir on | help + man |
--chdir-ops N | stop chdir workers after N bogo chdir operations | help + man |
--chmod N | start N workers that change the file mode bits via chmod(2) and fchmod(2) on the same file. | help + man |
--chmod-ops N | stop chmod workers after N bogo operations | help + man |
--chown N | start N workers that exercise chown(2) on the same file. | help + man |
--chown-ops N | stop the chown workers after N bogo chown(2) operations. | help + man |
--chroot N | start N workers that exercise chroot(2) on various valid and invalid chroot paths. | help + man |
--chroot-ops N | stop the chroot workers after N bogo chroot(2) operations. | help + man |
--chyperbolic N | start N workers that exercise complex sinh, cosh, and tanh libm complex hyperbolic functions using complex float, complex double and complex long double floating point variants. | help + man |
--chyperbolic-method M | select complex hyperbolic function to exercise | help + man |
--chyperbolic-ops N | stop after N chyperbolic bogo complex hyperbolic function operations | help + man |
--clock N | start N workers exercising clocks and POSIX timers. | help + man |
--clock-ops N | stop clock stress workers after N bogo operations. | help + man |
--clone N | start N workers that create clones (via the clone(2) and clone3(2) system calls). | help + man |
--clone-max N | try to create as many as N clone threads. | help + man |
--clone-ops N | stop clone stress workers after N bogo clone operations. | help + man |
--close N | start N workers that try to force race conditions on closing opened file descriptors. | help + man |
--close-fds N | specify the number of fds to close, the range is from 2 to 65535, with a default of 8. | help + man |
--close-ops N | stop close workers after N bogo close operations. | help + man |
--context N | start N workers that run three threads that use swapcontext(3) to implement the thread-to-thread context switching. | help + man |
--context-ops N | stop context workers after N bogo context switches. | help + man |
--copy-file N | start N stressors that copy a file using the Linux copy_file_range(2) system call. | help + man |
--copy-file-bytes N | copy file size, the default is 256 MB. | help + man |
--copy-file-io-bytes N | copy_file_range(2) copying I/O size, the default is 128 KB, range 4 K to 1 MB. | help + man |
--copy-file-ops N | stop after N copy_file_range() calls. | help + man |
-c, --cpu N | start N workers exercising the CPU by sequentially working through all the different CPU stress methods. | help + man |
-l, --cpu-load P | load CPU with P percent loading for the CPU stress workers. | help + man |
--cpu-load-slice S | note: this option is only useful when --cpu-load is less than 100%. | help + man |
--cpu-method M | specify stress cpu method M, default is all | help + man |
--cpu-old-metrics | as of version V0.14.02 the CPU stressor now normalizes each of the CPU stressor method bogo-op counters to try and ensure a similar bogo-op rate for all the methods to avoid the shorter running (and… | help + man |
--cpu-ops N | stop CPU stress workers after N bogo operations. | help + man |
--cpu-online N | start N workers that put randomly selected CPUs offline and online. | help + man |
--cpu-online-affinity | move the stressor worker to the CPU that will be next offlined. | help + man |
--cpu-online-all | The default is to never offline the first CPU. | help + man |
--cpu-online-ops N | stop after N offline/online operations | help + man |
--cpu-sched N | start N workers that exercise the scheduler by moving processes to different CPUs. | help + man |
--cpu-sched-ops N | stop after N bogo cpu scheduling operations | help + man |
--cpu-sched-procs N | specify number of child processes that each worker controls. | help + man |
--crc N | start N workers that perform a range of CRC calculations on 1024 bits of data. | help + man |
--crc-ops N | stop after N Cyclic Rundundancy Check bogo operations | help + man |
--crypt N | start N workers that encrypt a 16 character random password using crypt(3). | help + man |
--crypt-method M | select the encryption method, may be one of: bcrypt, bsdicrypt, descrypt, gost-yescrypt, MD5, NT, scrypt, SHA-1, SHA-256, SHA-512, SunMD5 and yescrypt. | help + man |
--crypt-ops N | stop after N bogo encryption operations. | help + man |
--ctrig N | start N workers that exercise complex sin, complex cos and complex tan libm trigonometric functions using complex float, complex double and complex long double floating point variants. | help + man |
--ctrig-method M | select complex trigonometric function to exercise | help + man |
--ctrig-ops N | stop after N trig bogo complex trigonometric operations | help + man |
--cyclic N | start N workers that exercise schedulers with cyclic nanosecond sleeps. | help + man |
--cyclic-budget N | fail the stressor if the maximum measured latency exceeds N nanoseconds. | help + man |
--cyclic-dist N | calculate and print a latency distribution with the interval of N nanoseconds. | help + man |
--cyclic-method M | specify cyclic method M, default is clock_ns | help |
--cyclic-ops N | stop after N cyclic timing cycles | help + man |
--cyclic-policy P | used rr or fifo scheduling policy | help |
--cyclic-prio N | real time scheduling priority 1..100 | help + man |
--cyclic-samples N | number of latency samples to take | help + man |
--cyclic-sleep N | sleep for N nanoseconds per test cycle using clock_nanosleep(2) with the CLOCK_REALTIME timer. | help + man |
--daemon N | start N workers that each create a daemon that dies immediately after creating another daemon and so on. | help + man |
--daemon-bloat N | specify N bytes of daemon child process memory bloat | help + man |
--daemon-ops N | stop daemon workers after N daemons have been created. | help + man |
--daemon-wait | wait for daemon child processes rather than let init handle the waiting. | help + man |
--dccp N | start N workers that send and receive data using the Datagram Congestion Control Protocol (DCCP) (RFC4340). | help + man |
--dccp-domain D | specify the domain to use, the default is ipv4. | help + man |
--dccp-if I | use network interface I, e.g. lo, eth0, etc. | help + man |
--dccp-ops N | stop dccp stress workers after N bogo operations. | help + man |
--dccp-opts option | DCCP data send options [send|sendmsg|sendmmsg] | help |
--dccp-port P | use DCCP ports P to P + number of workers - 1 | help + man |
--dccp-msgs N | send N messages per connect, send/receive, disconnect iteration. | help + man |
--dekker N | start N workers that exercises mutex exclusion between two processes using shared memory with the Dekker Algorithm. | help + man |
--dekker-ops N | stop dekker workers after N mutex operations. | help + man |
-D, --dentry N | start N workers that create and remove directory entries. | help + man |
--dentry-ops N | stop denty thrash workers after N bogo dentry operations. | help + man |
--dentry-order O | specify unlink order (reverse, forward, stride) | help |
--dentries N | create N dentries per dentry thrashing loop, default is 2048. | help + man |
--dentrycache N | start N workers that access non-existent files to fill the dentry cache with negative dentries. | help + man |
--dentrycache-method M | select dentrycache negative access method M | help |
--dentrycache-ops N | stop after N non-existtent files are accessed. | help + man |
--dev N | start N workers that exercise the /dev devices. | help + man |
--dev-alldev | exercise all devices (rather than just /dev/devname0) | help + man |
--dev-file name | specify the device file to exercise, for example, /dev/null. | help + man |
--dev-ops N | stop dev workers after N bogo device exercising operations. | help + man |
--dev-shm N | start N workers that fallocate large files in /dev/shm and then mmap these into memory and touch all the pages. | help + man |
--dev-shm-ops N | stop after N bogo allocation and mmap /dev/shm operations. | help + man |
--dfp N | start N workers that exercise addition, multiplication and division operations on a range of decimal floating point types. | help + man |
--dfp-method M | select the decimal floating point method to use, available methods are: | help + man |
--dfp-ops N | stop after N decimal floating point math bogo operations | help + man |
--dir N | start N workers that create, rename and remove directories using mkdir(2), rename(2) and rmdir(2). | help + man |
--dir-dirs N | select number of directories to exercise dir on | help + man |
--dir-ops N | stop directory thrash workers after N bogo directory operations. | help + man |
--dirdeep N | start N workers that create a depth-first tree of directories to a maximum depth as limited by PATH_MAX or ENAMETOOLONG (whichever occurs first). | help + man |
--dirdeep-bytes N | size of files to create per level (see | help + man |
--dirdeep-dirs N | create N directories at each tree level. | help + man |
--dirdeep-files N | create N files per level (see --dirdeep-bytes) | help + man |
--dirdeep-inodes N | consume up to N inodes per dirdeep stressor while creating directories and links. | help + man |
--dirdeep-ops N | stop directory depth workers after N bogo directory operations. | help + man |
--dirmany N | start N stressors that create as many files in a directory as possible and then remove them. | help + man |
--dirmany-bytes N | allocated file size, the default is 0. | help + man |
--dirmany-ops N | stop dirmany stressors after N empty files have been created. | help + man |
--dnotify N | start N workers performing file system activities such as making/deleting files/directories, renaming files, etc. | help + man |
--dnotify-ops N | stop dnotify stress workers after N dnotify bogo operations. | help + man |
--dup N | start N workers that perform dup(2) and then close(2) operations on /dev/zero. | help + man |
--dup-ops N | stop the dup stress workers after N bogo open operations. | help + man |
--dynlib N | start N workers that dynamically load and unload various shared libraries. | help + man |
--dynlib-ops N | stop workers after N bogo load/unload cycles. | help + man |
--easy-opcode N | start N workers that exercise 64 continuous pages of randomly selected simple CPU opcodes. | help + man |
--easy-opcode-ops N | stop after N executions of 64 continuous pages of opcodes. | help + man |
--efivar N | start N workers that exercise the Linux /sys/firmware/efi/efivars and /sys/firmware/efi/vars interfaces by reading the EFI variables. | help + man |
--efivar-ops N | stop the efivar stressors after N EFI variable read operations. | help + man |
--eigen N | start N workers that exercise the Eigen C++ matrix library for 2D matrix addition, multiplication, determinant, inverse and transpose operations on long double, double and float matrices. | help + man |
--eigen-method M | select the floating point method to use, available methods are: | help + man |
--eigen-ops N | stop after N Eigen matrix computations | help + man |
--eigen-size N | specify the size of the N x N eigen | help + man |
--enosys N | start N workers that exercise non-functional system call numbers. | help + man |
--enosys-ops N | stop after N bogo enosys system call attempts | help + man |
--env N | start N workers that create numerous large environment variables to try to trigger out of memory conditions using setenv(3). | help + man |
--env-ops N | stop after N bogo setenv/unsetenv attempts. | help + man |
--epoll N | start N workers that perform various related socket stress activity using epoll_wait(2) to monitor and handle new connections. | help + man |
--epoll-domain D | specify the domain to use, the default is unix (aka local). | help + man |
--epoll-ops N | stop epoll workers after N bogo operations. | help + man |
--epoll-port P | use socket ports P upwards | help + man |
--epoll-sockets N | specify the maximum number of concurrently open sockets allowed in the server. | help + man |
--epollmany N | start N workers that exercise many file descriptors using epoll_create1(2) and epoll_ctl(2). | help + man |
--epollmany-delete | by default file descriptors added to an epoll file descriptor are automatically deleted when the file descriptor is closed. | help + man |
--epollmany-fds N | specify number of file descriptors to created via epoll_create1(2). | help + man |
--epollmany-ops N | stop after N epoll_create1(2) operations | help + man |
--eth_sniff N | start N workers sniffing ethernet packets | help |
--eth_sniff-ops N | stop after N bogo sniffing ethernet packet operations | help |
--eventfd N | start N parent and child worker processes that read and write 8 byte event messages between them via the eventfd mechanism (Linux only). | help + man |
--eventfd-nonblock | enable EFD_NONBLOCK to allow non-blocking on the event file descriptor. | help + man |
--eventfd-ops N | stop eventfd workers after N bogo operations. | help + man |
--exec N | start N workers continually forking children that exec stress-ng and then exit almost immediately. | help + man |
--exec-fork-method M | select exec fork method: clone fork spawn vfork | help |
--exec-max P | create P child processes that exec stress-ng and then wait for them to exit per iteration. | help + man |
--exec-method M | select exec method: all, execve, execveat | help |
--exec-no-pthread | do not use pthread_create(3). | help + man |
--exec-ops N | stop exec stress workers after N bogo operations. | help + man |
--exit-group N | start N workers that create 16 pthreads and terminate the pthreads and the controlling child process using exit_group(2). | help + man |
--exit-group-ops N | stop after N iterations of pthread creation and deletion loops. | help + man |
--expmath N | start N workers that exercise various exponential functions with input values 0 to 1 in steps of 0.001; | help + man |
--expmath-method M | select exponential math function to exercise | help + man |
--expmath-ops N | stop after N expmath bogo exponential math operations | help + man |
--factor N | start N workers that factorize large integers using the GNU Multiple Precision Arithmetic Library. | help + man |
--factor-digits N | select the number of digits in the values to be factorized. | help + man |
--factor-ops N | stop after N factorisation operations | help + man |
--fallocate, -F N | start N workers continually fallocating (preallocating file space) and ftruncating (file truncating) temporary files. | help + man |
--fallocate-bytes N | allocated file size, the default is 1 GB. | help + man |
--fallocate-ops N | stop fallocate stress workers after N bogo fallocate operations. | help + man |
--fanotify N | start N workers performing file system activities such as creating, opening, writing, reading and unlinking files to exercise the fanotify event monitoring interface (Linux only). | help + man |
--fanotify-ops N | stop fanotify stress workers after N bogo fanotify events. | help + man |
--far-branch N | start N workers that exercise calls to tens of thousands of functions that are relatively far from the caller. | help + man |
--far-branch-flush | attempt to periodically flush instruction cache to produce instruction cache misses. | help + man |
--far-branch-ops N | stop after N far branching bogo operations | help + man |
--far-branch-pageout | where possible pageout and soft-offline randomly selected pages that contain the far branch functions. | help + man |
--far-branch-pages N | specify the number of pages to allocate for far branch functions. | help + man |
--fault N | start N workers that generate minor and major page faults. | help + man |
--fault-ops N | stop the page fault workers after N bogo page fault operations. | help + man |
--fcntl N | start N workers that perform fcntl(2) calls with various commands. | help + man |
--fcntl-ops N | stop the fcntl workers after N bogo fcntl operations. | help + man |
--fd-abuse N | start N workers that open file descriptors using various ways (file, dup, socket, pipe, timerfd, pidfd, userfaultfd, etc.) and perform valid and invalid file operations on these descriptors. | help + man |
--fd-abuse-ops N | stop after N file abuse file operation bogo-ops. | help + man |
--fd-fork N | start N workers that open files using dup(2) on a file (/dev/zero by default) and then copies these using multiple fork'd child processes and closes them with the fast clone_range(2) or close(2) or… | help + man |
--fd-fork-fds N | specify maximum number of file descriptors to be opened. | help + man |
--fd-fork-file file | select file to dup [ null, random, stdin, stdout, zero ] | help |
--fd-fork-ops N | stop after N rounds of 10000 dups, forking/closing/exiting and waiting for the child processes. | help + man |
--fd-race N | start N workers that attempt to force race conditions on opened file descriptors. | help + man |
--fd-race-dev | exercise /dev files for race conditions. | help + man |
--fd-race-ops N | stop after N fd_race bogo operations | help |
--fd-race-proc | exercise /proc files for race conditions. | help + man |
--fibsearch N | start N workers that use a search a sorted array of 32 bit integers using a Fibonacci search. | help + man |
--fibsearch-ops N | stop the fibsearch worker after N bogo fibsearch operations are completed. | help + man |
--fibsearch-size N | specify the size (number of 32 bit integers) in the array to fibsearch. | help + man |
--fiemap N | start N workers that each create a file with many randomly changing extents and has 4 child processes per worker that gather the extent information using the FS_IOC_FIEMAP ioctl(2). | help + man |
--fiemap-bytes N | specify the size of the fiemap'd file in bytes. | help + man |
--fiemap-ops N | stop after N FIEMAP ioctl bogo operations | help + man |
--fifo N | start N workers that exercise a named pipe by transmitting 64 bit integers. | help + man |
--fifo-data-size N | set the byte size of the fifo write/reads, default is 8, range 8..4096. | help + man |
--fifo-ops N | stop fifo workers after N bogo pipe write operations. | help + man |
--fifo-readers N | for each worker, create N fifo reader workers that read the named pipe using simple blocking reads. | help + man |
--file-ioctl N | start N workers that exercise various file specific ioctl(2) calls. | help + man |
--file-ioctl-ops N | stop file-ioctl workers after N file ioctl bogo operations. | help + man |
--filehole N | start N workers that write data, create file holes and zero fill a 16 MB file. | help + man |
--filehole-bytes N | set maximum size of each file for each filehole worker process, the default is 16 MB. | help + man |
--filehole-defrag | perform a naïve file defragment by copying a new version of the file to remove multiple extents and use the copy. | help + man |
--filehole-ops N | stop filehole workers after N rounds of bogo write/fallocate operations. | help + man |
--filename N | start N workers that exercise file creation using various length filenames containing a range of allowed filename characters. | help + man |
--filename-ops N | stop filename workers after N bogo filename tests. | help + man |
--filename-opts opt | use characters in the filename based on option opt'. | help + man |
--filerace N | start N workers that each run 8 concurrent processes that exercise a randomized set of file related system calls on random files. | help + man |
--filerace-files N | specifiy the maximum number of random files to exercise; | help + man |
--filerace-ops N | stop after N randomized file bogo-operations, this is not a reliable metric of performance because of the highly randomized actions occurring on randomly selected files. | help + man |
--filerace-procs N | specify the number of child processes per worker to spawn to exercise the file racing. | help + man |
--flipflop N | start N workers where each worker creates two groups of threads of the same size where each group is affined to a set of CPUs. | help + man |
--flipflop-bits N | specifies number of bits in the bitmap (and hence number of flip/flop thread pairs). | help + man |
--flipflop-ops N | stop after N bogo-ops, in this case a bogo-op is 100000 flip-flop operations. | help + man |
--flipflop-taskset1 S1 | list of CPUs to affine the flip threads to. | help + man |
--flipflop-taskset2 S2 | list of CPUs to affine the flop threads to. | help + man |
--flock N | start N workers locking on a single file. | help + man |
--flock-ops N | stop flock stress workers after N bogo flock operations. | help + man |
--flushcache N | start N workers that flush the data and instruction cache (where possible). | help + man |
--flushcashe-d-bytes | specify data cache size | help |
--flushcashe-i-bytes | specify instruction cache size | help |
--flushcache-ops N | stop after N flush cache bogo operations | help + man |
--fma N | start N workers that exercise single and double precision floating point multiplication and add operations on arrays of 512 floating point values. | help + man |
--fma-libc | use libc fma math functions if they are available. | help + man |
--fma-ops N | stop after N bogo-loops of the 3 above operations on 512 single and double precision floating point numbers. | help + man |
-f, --fork N | start N workers continually forking children that immediately exit. | help + man |
--fork-max P | create P child processes and then wait for them to exit per iteration. | help + man |
--fork-ops N | stop fork stress workers after N bogo operations. | help + man |
--fork-pageout | enable force paging-out of memory resident pages in fork stressor instances. | help + man |
--fork-unmap | attempt to unmap unused non-memory resident shared library pages to attempt to reduce anonymous vma copying. | help + man |
--fork-vm | enable detrimental performance virtual memory advice using madvise(2) on all pages of the forked process. | help + man |
--forkheavy N | start N workers that fork child processes from a parent that has thousands of allocated system resources. | help + man |
--forkheavy-allocs N | attempt N resource allocation loops per stressor instance. | help + man |
--forkheavy-mlock | attempt to mlock(2) future allocated pages into memory causing more memory pressure. | help + man |
--forkheavy-ops N | stop after N bogo fork operations | help + man |
--forkheavy-procs N | attempt to fork N processes per stressor. | help + man |
--fp N | start N workers that exercise addition, multiplication and division operations on a range of floating point types. | help + man |
--fp-method M | select the floating point method to use, available methods are: | help + man |
--fp-ops N | stop after N floating point math bogo operations | help + man |
--fp-error N | start N workers that generate floating point exceptions. | help + man |
--fp-error-ops N | stop after N bogo floating point exceptions. | help + man |
--fp-misc N | start N workers that exercise the following libm floating point macros: fpclassify(3), isgreater(3), isgreaterequal(3), isless(3), islessequal(3), islessgreater(3), isunordered(3), isfinite(3),… | help + man |
--fp-misc-ops N | stop after N floating point miscellaneous bogo operations | help + man |
--fp-subnormal N | start N workers that exercise addition, multiplication and division operations on a range of floating point types using subnormal floating point values. | help + man |
--fp-subnormal-ops N | stop after N subnormal floating point math bogo operations | help + man |
--fpunch N | start N workers that punch and fill holes in a 16 MB file using five concurrent processes per stressor exercising on the same file. | help + man |
--fpunch-bytes N | set maximum size of each file for each fpunch worker process, the default is 16 MB. | help + man |
--fpunch-ops N | stop fpunch workers after N punch and fill bogo operations. | help + man |
--fractal N | start N workers performing large integer fractalization | help + man |
--fractal-iterations N | specify the maximum number of iterations for the quadratic map computation of each point, default is 256 iterations. | help + man |
--fractal-method M | fractal method [ mandelbrot | julia ] | help |
--fractal-ops N | stop after N fractals have been generated. | help + man |
--fractal-xsize N | width of fractal | help |
--fractal-ysize N | height of fractal | help |
--fsize N | start N workers that exercise file size limits (via setrlimit(2) RLIMIT_FSIZE) with file sizes that are fixed, random and powers of 2. | help + man |
--fsize-ops N | stop after N bogo file size test iterations. | help + man |
--fstat N | start N workers fstat'ing files in a directory (default is /dev). | help + man |
--fstat-dir path | specify the directory to fstat to override the default of /dev. | help + man |
--fstat-ops N | stop fstat stress workers after N bogo fstat operations. | help + man |
--full N | start N workers that exercise /dev/full. | help + man |
--full-ops N | stop the stress full workers after N bogo I/O operations. | help + man |
--funccall N | start N workers that call functions of 1 through to 9 arguments. | help + man |
--funccall-method M | specify the method of funccall argument type to be used. | help + man |
--funccall-ops N | stop the funccall workers after N bogo function call operations. | help + man |
--funcret N | start N workers that pass and return by value various small to large data types. | help + man |
--funcret-method M | specify the method of funcret argument type to be used. | help + man |
--funcret-ops N | stop the funcret workers after N bogo function call operations. | help + man |
--futex N | start N workers that rapidly exercise the futex system call. | help + man |
--futex-ops N | stop futex workers after N bogo successful futex wait operations. | help + man |
--gamma N | start N workers that exercise tgamma and lgamma libm gamma functions using float, double and long double floating point variants. | help + man |
--gamma-method M | select gamma function to exercise | help + man |
--gamma-ops N | stop after N gamma bogo operations | help + man |
--get N | start N workers that call system calls that fetch data from the kernel, currently these are: getpid(2), getppid(2), getcwd(3), getgid(2), getegid(2), getuid(2), getgroups(2), getpgrp(2), getpgid(2),… | help + man |
--get-ops N | stop get workers after N bogo get operations. | help + man |
--get-slow-sync | attempt to synchronize system calls across the N get workers to try to force forms of locking contention in the kernel on the more complex cases. | help + man |
--getdent N | start N workers that recursively read directories /proc, /dev/, /tmp, /sys and /run using getdents(2) and getdents64(2) (Linux only). | help + man |
--getdent-ops N | stop getdent workers after N bogo getdent bogo operations. | help + man |
--getrandom N | start N workers that get 8192 random bytes from the /dev/urandom pool using the getrandom(2) system call (Linux) or getentropy(2) (OpenBSD). | help + man |
--getrandom-ops N | stop getrandom workers after N bogo get operations. | help + man |
--goto N | start N workers that perform 2048 forward branches (to next instruction) or backward branches (to previous instruction) for each bogo operation loop. | help + man |
--goto-direction D | select goto direction forward, backward, random | help |
--goto-ops N | stop goto workers after N bogo loops of 2048 branch instructions. | help + man |
--gpu N | start N worker that exercise the GPU. | help + man |
--gpu-devnode name | specify the device node name of the GPU device, the default is /dev/dri/renderD128. | help + man |
--gpu-frag N | specify shader core usage per pixel, this sets N loops in the fragment shader. | help + man |
--gpu-ops N | stop gpu workers after N render loop operations. | help + man |
--gpu-tex-size N | specify upload texture N × N, by default this value is 4096 × 4096. | help + man |
--gpu-upload N | specify upload texture N times per frame, the default value is 1. | help + man |
--gpu-xsize X | use a framebuffer size of X pixels. | help + man |
--gpu-ysize Y | use a framebuffer size of Y pixels. | help + man |
--handle N | start N workers that exercise the name_to_handle_at(2) and open_by_handle_at(2) system calls. | help + man |
--handle-ops N | stop after N handle bogo operations. | help + man |
--hash N | start N workers that exercise various hashing functions. | help + man |
--hash-method M | specify the hashing method to use, by default all the hashing methods are cycled through. | help + man |
--hash-ops N | stop after N hash bogo operations | help + man |
-d, --hdd N | start N workers continually writing, reading and removing temporary files. | help + man |
--hdd-bytes N | write N bytes for each hdd process, the default is 1 GB. | help + man |
--hdd-ops N | stop hdd stress workers after N bogo operations. | help + man |
--hdd-opts list | specify various stress test options as a comma separated list. | help + man |
--hdd-sleep N | sleep N seconds after each read/write cycle (default is off) | help + man |
--hdd-write-size N | set the default write size to N bytes | help + man |
--heapsort N | start N workers that sort 32 bit integers using the BSD heapsort. | help + man |
--heapsort-method M | select sort method [ heapsort-libc | heapsort-nonlibc ] | help |
--heapsort-ops N | stop heapsort stress workers after N bogo heapsorts. | help + man |
--heapsort-size N | specify number of 32 bit integers to sort, default is 262144 (256 × 1024). | help + man |
--hrtimers N | start N workers that exercise high resolution times at a high frequency. | help + man |
--hrtimers-adjust | enable automatic timer rate adjustment to try to maximize the hrtimer frequency. | help + man |
--hrtimers-ops N | stop hrtimers stressors after N timer event bogo operations | help + man |
--hsearch N | start N workers that search a 80% full hash table using hsearch(3). | help + man |
--hsearch-ops N | stop the hsearch workers after N bogo hsearch operations are completed. | help + man |
--hsearch-size N | specify the number of hash entries to be inserted into the hash table. | help + man |
--hugepage N | start N workers that exercise page merging (collapsing) and splitting on huge pages with two concurrent threads of execution (one merging and the other splitting). | help + man |
--hugepage-dontneed | use MADV_DONTNEED where possible to try to split huge pages. | help + man |
--hugepage-method | select method of splitting [ forward | random | reverse ] | help |
--hugepage-num N | use N huge pages for the allocation. | help + man |
--hugepage-ops N | stop hugepage workers after N bogo huge page rebuild operations | help + man |
--hugepage-remove | use MADV_REMOVE where possible to try to split huge pages. | help + man |
--hyperbolic N | start N workers that exercise sinh, cosh, and tanh libm hyperbolic functions using float, double and long double floating point variants. | help + man |
--hyperbolic-method M | select hyperbolic function to exercise | help + man |
--hyperbolic-ops N | stop after N hyperbolic bogo hyperbolic function operations | help + man |
--icache N | start N workers that stress the instruction cache by forcing instruction cache reloads. | help + man |
--icache-ops N | stop the icache workers after N bogo icache operations are completed. | help + man |
--icache-pages N | specify the number of pages to use for instruction cache stressing for each stressor instance. | help + man |
--icmp-flood N | start N workers that flood localhost with randomly sized ICMP ping packets. | help + man |
--icmp-flood-max-size | use a maximum packet size of 65535 bytes instead of the default of 1000 bytes. | help + man |
--icmp-flood-ops N | stop icmp flood workers after N ICMP ping packets have been sent. | help + man |
--idle-page N | start N workers that walk through every page exercising the Linux /sys/kernel/mm/page_idle/bitmap interface. | help + man |
--idle-page-ops N | stop after N idle page scan bogo operations | help + man |
--inode-flags N | start N workers that exercise inode flags using the FS_IOC_GETFLAGS and FS_IOC_SETFLAGS ioctl(2) and inode attributes using file_getattr(2) and file_getatt(2). | help + man |
--inode-flags-ops N | stop the inode-flags workers after N ioctl flag setting attempts. | help + man |
--inotify N | start N workers performing file system activities such as making/deleting files/directories, moving files, etc. | help + man |
--inotify-ops N | stop inotify stress workers after N inotify bogo operations. | help + man |
--insertionsort N | start N workers that sort 32 bit integers using insertion sort. | help + man |
--insertionsort-ops N | stop insertionsort stress workers after N bogo insertion sorts. | help + man |
--insertionsort-size N | specify number of 32 bit integers to sort, default is 16384 (16 × 1024). | help + man |
--intmath N | start N workers that perform addition, subtraction, multiplication, division and modulo math operations on 128, 64, 32, 16 and 8 bit signed integers. | help + man |
--intmath-fast | when available use int_fast64_t, int_fast32_t, int_fast16_t and int_fast8_t types instead of int64_t, int32_t, int16_t and int8_t types. | help + man |
--intmath-method method | select the integer math method to use, available methods are: | help + man |
--intmath-ops N | stop intmath workers after N bogo integer math operations. | help + man |
-i, --io N | start N workers continuously calling sync(2) to commit buffer cache to disk. | help + man |
--io-ops N | stop io stress workers after N bogo operations. | help + man |
--iomix N | start N workers that perform a mix of sequential, random and memory mapped read/write operations as well as random copy file read/writes, direct I/O read/writes, forced sync'ing and (if run as root)… | help + man |
--iomix-bytes N | write N bytes for each iomix worker process, the default is 1 GB. | help + man |
--iomix-ops N | stop iomix stress workers after N bogo iomix I/O operations. | help + man |
--ioport N | start N workers that perform bursts of 16 reads and 16 writes of ioport 0x80 (x86 Linux systems only). | help + man |
--ioport-ops N | stop the ioport stressors after N bogo I/O operations | help + man |
--ioport-opts O | option to select ioport access [ in | out | inout ] | help |
--ioport-port | post | vga-dac-r | bochs-debug | help |
--ioprio N | start N workers that exercise the ioprio_get(2) and ioprio_set(2) system calls (Linux only). | help + man |
--ioprio-ops N | stop after N io bogo iopriority operations | help + man |
--io-uring N | start N workers that perform various io-uring file operations using the Linux io-uring interface. | help + man |
--io-uring-entries N | specify the number of io-uring ring entries. | help + man |
--io-uring-ops N | stop after N rounds of io-uring operations. | help + man |
--io-uring-rand | randomize order of io-uring operations and file seek locations. | help + man |
--ipsec-mb N | start N workers that perform cryptographic processing using the highly optimized Intel Multi-Buffer Crypto for IPsec library. | help + man |
--ipsec-mb-feature F | specify CPU feature F | help |
--ipsec-mb-jobs N | Process N multi-block rounds of cryptographic processing per iteration. | help + man |
--ipsec-mb-method M | specify crypto/integrity method | help |
--ipsec-mb-ops N | stop after N rounds of processing of data using the cryptographic routines. | help + man |
--itimer N | start N workers that exercise the system interval timers. | help + man |
--itimer-freq F | set the itimer frequency, limited by jiffy clock rate | help + man |
--itimer-ops N | stop itimer stress workers after N bogo itimer SIGPROF signals. | help + man |
--itimer-rand | select an interval timer frequency based around the interval timer frequency ±12.5% random jitter. | help + man |
--jpeg N | start N workers that use jpeg compression on a machine generated plasma field image. | help + man |
--jpeg-height N | use a RGB sample image height of H pixels. | help + man |
--jpeg-image type | image type: one of brown, flat, gradient, noise, plasma or xstripes | help |
--jpeg-ops N | stop after N jpeg compression operations. | help + man |
--jpeg-quality Q | compression quality 1 (low) .. | help + man |
--jpeg-width N | use a RGB sample image width of H pixels. | help + man |
--judy N | start N workers that insert, search and delete 32 bit integers in a Judy array using a predictable yet sparse array index. | help + man |
--judy-ops N | stop the judy workers after N bogo judy operations are completed. | help + man |
--judy-size N | specify the size (number of 32 bit integers) in the Judy array to exercise. | help + man |
--kcmp N | start N workers that use kcmp(2) to compare parent and child processes to determine if they share kernel resources. | help + man |
--kcmp-ops N | stop kcmp workers after N bogo kcmp operations. | help + man |
--key N | start N workers that create and manipulate keys using add_key(2) and ketctl(2). | help + man |
--key-ops N | stop key workers after N bogo key operations. | help + man |
--kill N | start N workers sending SIGUSR1 kill(2) signals to a SIG_IGN signal handler in the stressor and SIGUSR1 kill signal to a child stressor with a SIGUSR1 handler. | help + man |
--kill-ops N | stop kill workers after N bogo kill operations. | help + man |
--klog N | start N workers exercising the kernel syslog(2) system call. | help + man |
--klog-ops N | stop klog workers after N syslog operations. | help + man |
--kvm N | start N workers that create, run and destroy a minimal virtual machine, 64 bit ARM, RISC-V and x86 ARM Linux only. | help + man |
--kvm-ops N | stop kvm stressors after N virtual machines have been created, run and destroyed. | help + man |
--l1cache N | start N workers that exercise the CPU level 1 cache with reads and writes. | help + man |
--l1cache-line-size N | specify the level 1 cache line size (in bytes) | help + man |
--l1cache-method M | l1 cache thrashing method: forward, reverse, random | help |
--l1cache-mlock | attempt to mlock(2) the l1cache size buffer into memory to prevent it from being swapped out. | help + man |
--l1cache-sets N | specify the number of level 1 cache sets | help + man |
--l1cache-size N | specify the level 1 cache size (in bytes) | help + man |
--l1cache-ways N | only fill specified number of cache ways | help + man |
--landlock N | start N workers that exercise Linux 5.13 landlocking. | help + man |
--landlock-ops N | stop the landlock stressors after N landlock ruleset bogo operations. | help + man |
--lease N | start N workers locking, unlocking and breaking leases via the fcntl(2) F_SETLEASE operation. | help + man |
--lease-breakers N | start N lease breaker child processes per lease worker. | help + man |
--lease-ops N | stop lease workers after N bogo operations. | help + man |
--led N | start N workers that exercise the /sys/class/leds interfaces to set LED brightness levels and the various trigger settings. | help + man |
--led-ops N | stop after N interfaces are exercised. | help + man |
--link N | start N workers creating and removing hardlinks. | help + man |
--link-ops N | stop link stress workers after N bogo operations. | help + man |
--link-sync | enable sync'ing after linking/unlinking | help + man |
--list N | start N workers that exercise list data structures. | help + man |
--list-method M | select list method: all, circleq, list, slist, slistt, stailq, tailq | help |
--list-ops N | stop list stressors after N bogo ops. | help + man |
--list-size N | specify the size of the list, where N is the number of 64 bit integers to be added into the list. | help + man |
--llc-affinity N | start N workers that exercise the last level of cache (LLC) by read/write activity across a LLC sized buffer and then changing CPU affinity after each round of read/writes. | help + man |
--llc-affinity-clflush | where possible, flush cachelines after each cacheline write, x86 and ppc64 only. | help + man |
--llc-affinity-mlock | attempt to mlock(2) the LLC sized buffer into memory to prevent it from being swapped out. | help + man |
--llc-affinity-numa | assign memory mapped pages to randomly selected NUMA nodes. | help + man |
--llc-affinity-ops N | stop after N low-level-cache bogo operations | help + man |
--loadavg N | start N workers that attempt to create thousands of pthreads that run at the lowest nice priority to force very high load averages. | help + man |
--loadavg-max N | set the maximum number of pthreads to create to N. | help + man |
--loadavg-ops N | stop loadavg workers after N bogo scheduling yields by the pthreads have been reached. | help + man |
--locka N | start N workers that randomly lock and unlock regions of a file using the POSIX advisory locking mechanism (see fcntl(2), F_SETLK, F_GETLK). | help + man |
--locka-ops N | stop locka workers after N bogo locka operations. | help + man |
--lockbus N | start N workers that rapidly lock and increment 64 bytes of randomly chosen memory from a 16 MB mmap'd region (Intel x86 and ARM CPUs only). | help + man |
--lockbus-bytes N | exercise bus locking over N bytes, the default is 16 MB. | help + man |
--lockbus-nosplit | disable split locks that lock across cache line boundaries. | help + man |
--lockbus-ops N | stop lockbus workers after N bogo operations. | help + man |
--lockf N | start N workers that randomly lock and unlock regions of a file using the POSIX lockf(3) locking mechanism. | help + man |
--exercise-feature list | enable stressors that exercises one or more stressor features specified in the given list, for example: --exercise-features branch,registers to exercise branching and processor registers. (in the manual page but not in --help) | man |
--exercise-library list | enable stressors that exercises one or more libraries specified in the given list, for example: --exercise-library pthread,z for libpthread and libz libraries. (in the manual page but not in --help) | man |
--exercise-syscall list | enable stressors that exercises one or more system calls specified in the given list, for example: --exercise-syscall mmap,fork for the mmap and fork system calls. (in the manual page but not in --help) | man |
--sync-start | synchronize start, wait for stressors to be created and start all stressors once they are all in a ready to run state. (in the manual page but not in --help) | man |
--taskset-random | randomly change stressor CPU affinity at five times the clock tick rate (if defined) or at 400Hz while waiting for stressors to complete. (in the manual page but not in --help) | man |
--dentry-negative | access files that don't exist to create negative dentries in the dentry cache. (in the manual page but not in --help) | man |
--eth-sniff N | start N stressors that sniff ethernet packets. (in the manual page but not in --help) | man |
--eth-sniff-ops N | stop after N bogo ethernet packet sniffs. (in the manual page but not in --help) | man |
--fd-race-race-ops N | stop after N file descriptors have been exercised. (in the manual page but not in --help) | man |
--flushcache-d-bytes N | specify size of data region to be data flushed, range 1K to 4GB with a default of the lower level data cache size. (in the manual page but not in --help) | man |
--flushcache-i-bytes N | specify size of instruction region be instruction flushed, range 1K to 4GB with a default of the level 1 instruction cache size. (in the manual page but not in --help) | man |
--fp-subnormal-method method | select the floating point method to use, available methods are: (in the manual page but not in --help) | man |
--fractal-sizex N | set the maximum width of the fractal, default is 1024 points. (in the manual page but not in --help) | man |
--fractal-sizey N | set the maximum height of the fractal, default is 1024 points. (in the manual page but not in --help) | man |
--l1cache-ops N | specify the number of cache read/write bogo-op loops to run (in the manual page but not in --help) | man |
--llc-affinity-size N | override the default LLC cache size setting to N bytes. (in the manual page but not in --help) | man |
--lockf-nonblock | instead of using blocking F_LOCK lockf(3) commands, use non-blocking F_TLOCK commands and re-try if the lock fails. (in the manual page but not in --help) | man |
--lockf-ops N | stop lockf workers after N bogo lockf operations. (in the manual page but not in --help) | man |
--lockmix N | start N workers that randomly lock and unlock regions of a file using the BSD flock(2), locka (advisory), POSIX lockf(3) and Linux open file lock (lockofd) locking mechanisms. (in the manual page but not in --help) | man |
--lockmix-ops N | stop lockmix workers after N bogo lockmix operations. (in the manual page but not in --help) | man |
--lockofd N | start N workers that randomly lock and unlock regions of a file using the Linux open file description locks (see fcntl(2), F_OFD_SETLK, F_OFD_GETLK). (in the manual page but not in --help) | man |
--lockofd-ops N | stop lockofd workers after N bogo lockofd operations. (in the manual page but not in --help) | man |
--logmath N | start N workers that exercise various libm logarithmic functions with input values 1 to 10000. (in the manual page but not in --help) | man |
--logmath-ops N | stop after N logarithmic bogo-operation loops. (in the manual page but not in --help) | man |
--logmath-method method | specify a logarithmic function to exercise. (in the manual page but not in --help) | man |
--longjmp N | start N workers that exercise setjmp(3)/longjmp(3) by rapid looping on longjmp calls. (in the manual page but not in --help) | man |
--longjmp-ops N | stop longjmp stress workers after N bogo longjmp operations (1 bogo op is 1000 longjmp calls). (in the manual page but not in --help) | man |
--loop N | start N workers that exercise the loopback control device. (in the manual page but not in --help) | man |
--loop-bytes N | specify the size of the loop device in bytes, range 1MB to 1GB, the default is 2MB. (in the manual page but not in --help) | man |
--loop-ops N | stop after N bogo loopback creation/deletion operations. (in the manual page but not in --help) | man |
--lsearch N | start N workers that linear search an unsorted array of 32 bit integers using lsearch(3). (in the manual page but not in --help) | man |
--lsearch-ops N | stop the lsearch workers after N bogo lsearch operations are completed. (in the manual page but not in --help) | man |
--lsearch-size N | specify the size (number of 32 bit integers) in the array to lsearch. (in the manual page but not in --help) | man |
--lsm N | start N workers that exercise the LSM system calls lsm_list_modules(2) and lsm_get_self_attr(2), (Linux only). (in the manual page but not in --help) | man |
--lsm-ops N | stop after N loops of fetching security modules lists and fetching LSM attributes. (in the manual page but not in --help) | man |