stress_ng
stress-ng
stress-ng atomic
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. This stressor is only available for builds using GCC 4.7.4 or higher. The stressor forces many front end cache stalls and cache references. Note that 32 bit systems do not currently exercise 64 bit integers. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:atomic- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,443
- Range of measurements
- 7.8 – 1.5K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,443 measurements)
stress-ng div16 single-core
Stress a single vCPUvCPU: virtual CPUA CPU of a virtual machine, the unit in which cloud vendors sell compute. It is usually one hardware thread of a physical core with SMT, so two vCPUs may share one physical core.WikipediaGlossary core with the div16 method of stress-ngstress-ngAn open-source tool that loads a computer in selectable ways, with hundreds of stress tests (stressors) that exercise the CPU, memory, file systems, and kernel interfaces. With --metrics, it reports each stressor's throughput in bogo ops/s.stress-ng on GitHubGlossary, and count the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:best1- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 3,737
- Total measurements
- 3,737
- Range of measurements
- 132.9 – 4.6K ops/s
- Better
- ↑ Higher is better
This benchmark measures single-threaded CPUCPU: Central Processing UnitThe general-purpose processor of a computer, which runs the operating system and programs. A CPU has one or more physical cores, and with SMT each core runs two or more hardware threads.WikipediaGlossary performance only, so scores do not increase with vCPU count beyond one core.
Score distribution (3,737 measurements)
stress-ng div16 multi-core
Stress the CPU with the div16 method of stress-ng using a varying number of vCPU cores, and count the measured maximum total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:bestn- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 3,737
- Total measurements
- 3,737
- Range of measurements
- 157 – 713.5K ops/s
- Better
- ↑ Higher is better
Score distribution (3,737 measurements)
stress-ng bitonicsort
Start N workers that sort 32 bit integers using bitonic sort. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:bitonicsort- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 0.8 – 2.5K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng bitops
Start N workers that perform various calculations using 32 bit integer manipulation operations. Many of these are derived from the Standford "Bit Twiddling Hacks" (Sean Eron Anderson) and Hacker's Delight (Henry S. Warren, Jr.). The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:bitops- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 16K – 39M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng branch
Start N workers that randomly branch to 1024 randomly selected locations and hence exercise the CPU branch prediction logic. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:branch- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 19.7K – 67.5M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng bsearch
Start N workers that binary search a sorted array of 32 bit integers using bsearch. By default, there are 65536 elements in the array. This is a useful method to exercise random access of memory and processor cache. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:bsearch- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 30 – 80.2K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng bubblesort
Start N workers that sort 32 bit integers using bubblesort. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:bubblesort- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,224
- Total measurements
- 4,444
- Range of measurements
- 0.2 – 268.8 ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,444 measurements)
stress-ng cache
Start N workers that perform random wide spread memory read and writes to thrash the CPU cache. The code does not intelligently determine the CPU cache configuration and so it may be sub-optimal in producing hit-miss read/write activity for some processors. Note: to exercise cache misses it is recommended to instead use the matrix-3d stressor using the --matrix-3d-zyx option. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:cache- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,447
- Range of measurements
- 40.7K – 12.9M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,447 measurements)
stress-ng cachehammer
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 which is shared among all the cache stressors and is the size of the L3 cache, one is local to each instance and is 4 times the L3 cache size and one is a single page mapping that cannot be read or written. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:cachehammer- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,447
- Range of measurements
- 21K – 56.5M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,447 measurements)
stress-ng cacheline
Start N workers that exercise reading and writing individual bytes in a shared buffer that is the size of a cache line. Each stressor will run 1 or more processes to exercise bytes that are next to each other. The number of per stressor processes run will be scaled so that at least all N bytes of a N byte cache line are exercised. The intent is to try and trigger cacheline corruption, stalls and misses with shared memory accesses. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:cacheline- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,454
- Range of measurements
- 0.52 – 6.5K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,454 measurements)
stress-ng clock
Start N workers exercising clocks and POSIX timers. For all known clock types this will exercise clock_getres, clock_gettime and clock_nanosleep. For all known timers it will create a random duration timer and busy poll this until it expires. This stressor will cause frequent context switching. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:clock- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 2.3K – 645K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng clone
Start N workers that create clones (via the clone and clone3 system calls). This will rapidly try to create a default of 8192 clones that immediately die and wait in a zombie state until they are reaped. Once the maximum number of clones is reached (or clone fails because one has reached the maximum allowed) the oldest clone thread is reaped and a new clone is then created in a first-in first-out manner, and then repeated. A random clone flag is selected for each clone to try to exercise different clone operations. The clone stressor is a Linux only option. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:clone- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 14.9 – 39.3K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng context
Start N workers that run three threads that use swapcontext to implement the thread-to-thread context switching. This exercises rapid process context saving and restoring and is bandwidth limited by register and memory save and restore rates. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:context- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 403.6 – 1.9M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng CPU all
Stress the CPU with all available methods supported by stress-ng, and count the total bogo operations per second (in real time) based on wall clock run time. The stress methods include bit operations, recursive calculations, integer divisions, floating point operations, matrix multiplication, stats, trigonometric, and hash functions. Note that this is to be deprecated in favor of stress_ng:div16.
Benchmark details
- Benchmark ID
stress_ng:cpu_all- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 3,741
- Total measurements
- 7,362
- Range of measurements
- 119.9 – 713.5K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Stressing a single core or all cores. | 1 2 3 4 6 8 10 12 14 15 16 20 22 24 26 28 30 32 36 38 40 44 45 48 52 56 60 64 72 80 88 90 96 104 112 120 128 144 160 176 180 192 208 224 288 360 384 416 448 |
Score distribution (7,362 measurements)
stress-ng cpu-sched
Start N workers that exercise the scheduler by moving processes to different CPUs. Each worker starts 16 child processes and repeatedly moves the processes to different CPUs and attempts changes their scheduler policy using SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_EXT, SCHED_DEADLINE, SCHED_RR and SCHED_FIFO policies. The choice of CPU placement is based on 8 different mechanisms and is changed every second to mix process placements on all the available CPUS. The child processes are run with randomizied niceniceA Unix command that runs a program with a changed scheduling priority, from -20 (highest) to 19 (lowest). Raising a process's priority above the default needs the CAP_SYS_NICE capability, which root has.man pageGlossary settings to exercise scheduler prioritization. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:cpu_sched- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,213
- Total measurements
- 4,423
- Range of measurements
- 5.6 – 22.5K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,423 measurements)
stress-ng crypt
Start N workers that encrypt a 16 character random password using crypt. The password is encrypted using bcrypt bsdicrypt descrypt gost-yescrypt MD5 NT scrypt SHA-1 SHA-256 SHA-512 SunMD5 and yescrypt encryption methods. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:crypt- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 335.7 – 858.9K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng div16
Stress the CPU with the div16 method of stress-ng using a varying number of vCPU cores, and count the measured maximum total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:div16- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 3,737
- Total measurements
- 62,298
- Range of measurements
- 132.9 – 713.5K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Number of CPU cores stressed. | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 34 36 38 40 42 44 45 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 96 98 100 102 104 108 110 112 114 116 120 124 126 128 130 132 136 138 140 144 150 154 156 160 162 168 170 174 176 180 182 186 192 196 198 204 208 210 216 220 224 228 234 238 240 242 252 260 264 266 270 276 280 286 288 294 300 308 312 322 324 330 336 338 348 350 352 360 364 372 378 384 390 392 406 416 420 434 448 |
Score distribution (62,298 measurements)
stress-ng eigen
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. This currently is only available for gcc/g++ builds. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:eigen- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 1.1K – 4.4M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng eventfd
Start N parent and child worker processes that read and write 8 byte event messages between them via the eventfd mechanism (Linux only). The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:eventfd- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 3.3K – 12.2M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng expmath
Start N workers that exercise various exponential functions with input values 0 to 1 in steps of 0.001; the results are sanity checked to ensure no variation occurs after each round of 10000 computations. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:expmath- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 193.7 – 1.1M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng fault
Start N workers that generates minor and major page faults. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:fault- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 855.2 – 483.1K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng fibsearch
Start N workers that use a search a sorted array of 32 bit integers using a Fibonacci search. A Fibonacci search is similar to a bsearch except that it uses the Fibonacci series to divide the search into unequal sized spaces. It avoids the costly division operator found in bsearches and examines closer elements on each search step so there is a slight compute and cache advantage over bsearch. By default, there are 65536 elements in the array. This is a useful method to exercise random access of memory and processor cache. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:fibsearch- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 35.4 – 83.1K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng fma
Start N workers that exercise single and double precision floating point multiplication and add operations on arrays of 512 floating point values. More modern processors (Intel Haswell, AMD Bulldozer and Piledriver) and modern C compilers these will be performed by fused-multiply-add (fma3) opcodes. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:fma- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 88.9K – 338.7M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng fork
Start N workers continually forking children that immediately exit. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:fork- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 339.8 – 162.7K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng fp
Start N workers that exercise addition, multiplication and division operations on a range of floating point types. For each type, 8 floating point values are operated upon 65536 times in a loop per bogo op. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:fp- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 26.4 – 66.5K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng fractal
Start N workers that generate 2D fractals. By default a 1024 x 1024 point Mandelbrot set is computed with a maximum of 256 iterations per point in the iterative compute loop. The fractal is computed row by row with multiple rows shared amongst the N fractal stressor instances. Double precision floating point values are used for the points in the complex set of values. Naive computation is used with no special algorithmic shortcuts or interpolation. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:fractal- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 0.8 – 2K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng funccall
Start N workers that call functions of 1 through to 9 arguments. By default all functions with a range of argument types are called, however, this can be changed using the --funccall-method option. This exercises stack function argument passing and re-ordering on the stack and in registers. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:funccall- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 61.1 – 435.4K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng funcret
Start N workers that pass and return by value various small to large data types. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:funcret- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 2K – 7.2M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng getrandom
Start N workers that get 8192 random bytes from the /dev/urandom pool using the getrandom system call (Linux) or getentropy (OpenBSD). The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:getrandom- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 5.2K – 17.5M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng hash
Start N workers that exercise various hashing functions. Random strings from 1 to 128 bytes are hashed and the hashing rate and chi squared is calculated from the number of hashes performed over a period of time. The chi squared value is the goodness-of-fit measure, it is the actual distribution of items in hash buckets versus the expected distribution of items. Typically a chi squared value close to 1.0 indicates a good hash distribution. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:hash- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 15.4K – 53.4M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng heapsort
Start N workers that sort 32 bit integers using the BSD heapsort. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:heapsort- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 1 – 2.9K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng hrtimers
Start N workers that exercise high resolution times at a high frequency. Each stressor starts 32 processes that run with random timer intervals of 0..499999 nanoseconds. Running this stressor with appropriate privilege will run these with the SCHED_RR policy. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:hrtimers- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,227
- Total measurements
- 4,453
- Range of measurements
- 8.7K – 26.9M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,453 measurements)
stress-ng hsearch
Start N workers that search a 80% full hash table using hsearch. By default, there are 8192 elements inserted into the hash table. This is a useful method to exercise access of memory and processor cache. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:hsearch- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 843.4 – 2.1M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng hyperbolic
Start N workers that exercise sinh, cosh, and tanh libm hyperbolic functions using float, double and long double floating point variants. Each function is exercised 10000 times per bogo-operation. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:hyperbolic- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 191.7 – 1.2M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng insertionsort
Start N workers that sort 32 bit integers using insertion sort. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:insertionsort- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 1 – 2.7K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng intmath
Start N workers that perform addition, subtraction, multiplication, division and modulo math operations on 128, 64, 32, 16 and 8 bit signed integers. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:intmath- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 6.5K – 16.7M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng ipsec-mb
Start N workers that perform cryptographic processing using the highly optimized Intel Multi-Buffer Crypto for IPsec library. Depending on the features available, SSE, AVX, AVX and AVX512 CPU features will be used on data encrypted by SHA, DES, CMAC, CTR, HMAC MD5, HMAC SHA1 and HMAC SHA512 cryptographic routines. This is only available for x86-64AMD64The 64-bit version of the x86 instruction set architecture, introduced by AMD in 2003 and also implemented by Intel, which runs most cloud servers. Linux distributions and Docker name it amd64 or x86_64.WikipediaGlossary modern Intel CPUs. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:ipsec_mb- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- —
- Total measurements
- —
- Range of measurements
- —
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | — |
stress-ng jpeg
Start N workers that use jpeg compression on a machine generated plasma field image. The default image is a plasma field, however different image types may be selected. The starting raster line is changed on each compression iteration to cycle around the data. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:jpeg- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 82.6 – 192.7K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng l1cache
Start N workers that exercise the CPU level 1 cache with reads and writes. A cache aligned buffer that is twice the level 1 cache size is read and then written in level 1 cache set sized steps over each level 1 cache set. This is designed to exercise cache block evictions. The bogo-op count measures the number of million cache lines touched. Where possible, the level 1 cache geometry is determined from the kernel, however, this is not possible on some architectures or kernels, so one may need to specify these manually. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:l1cache- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,213
- Total measurements
- 4,423
- Range of measurements
- 17.7 – 195.5K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,423 measurements)
stress-ng logmath
Start N workers that exercise various libm logarithmic functions with input values 1 to 10000. Results are sanity checked to ensure no variation occurs after each round of 10000 computations. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:logmath- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 237.5 – 1.7M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng malloc
Start N workers continuously calling malloc, calloc, realloc, posix_memalign, aligned_alloc, memalign and free. By default, up to 65536 allocations can be active at any point, but this can be altered with the --malloc-max option. Allocation, reallocation and freeing are chosen at random; 50% of the time memory is allocation (via one of malloc, calloc or realloc, posix_memalign, aligned_alloc, memalign) and 50% of the time allocations are free'd. Allocation sizes are also random, with the maximum allocation size controlled by the --malloc-bytes option. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:malloc- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,227
- Total measurements
- 4,452
- Range of measurements
- 18K – 388.9M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng matrix
Start N workers that perform various matrix operations on floating point values. Testing on 64 bit x86 hardware shows that this provides a good mix of memory, cache and floating point operations and is an excellent way to make a CPU run hot. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:matrix- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 315.9 – 1.5M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng matrix-3d
Start N workers that perform various 3D matrix operations on floating point values. Testing on 64 bit x86 hardware shows that this provides a good mix of memory, cache and floating point operations and is an excellent way to make a CPU run hot. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:matrix_3d- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 48.1 – 50.1K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng mcontend
Start N workers that produce memory contention read/write patterns. Each stressor runs with 5 threads that read and write to two different mappings of the same underlying physical page. Various caching operations are also exercised to cause sub-optimal memory access patterns. The threads also randomly change CPU affinityCPU affinityThe set of CPU cores that a thread or process may run on, which the operating system's scheduler keeps to when it places the thread. It includes every core by default; restricting it to chosen cores is called thread binding or CPU pinning.Linux man pageGlossary to exercise CPU and memory migration stress. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:mcontend- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 0.1 – 501.8K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng memcpy
Start N workers that copies data to and from a buffer using memcpy and then move the data in the buffer with memmove with 3 different alignments. This will exercise the data cache and memory copying. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:memcpy- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 37.2 – 174.7K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng memrate
Start N workers that exercise a buffer with 1024, 512, 256, 128, 64, 32, 16 and 8 bit reads and writes. 1024, 512 and 256 reads and writes are available with compilers that support integer vectors. x86-64 cpus that support uncached (non-temporal "nt") writes also exercise 128, 64 and 32 writes providing higher write rates than the normal cached writes. x86-64 also exercises repeated string stores using 64, 32, 16 and 8 bit writes. CPUs that support prefetching reads also exercise 64 prefetched "pf" reads. This memory stressor allows one to also specify the maximum read and write rates. The stressors will run at maximum speed if no read or write rates are specified. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:memrate- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,189
- Total measurements
- 4,371
- Range of measurements
- 0.1 – 135.5 ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,371 measurements)
stress-ng memthrash
Start N workers that thrash and exercise a 16 MB buffer in various ways to try and trip thermal overrun. Each stressor will start 1 or more threads. The number of threads is chosen so that there will be at least 1 thread per CPU. Note that the optimal choice for N is a value that divides into the number of CPUs. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:memthrash- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,225
- Total measurements
- 4,439
- Range of measurements
- 7.7 – 3.4K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,439 measurements)
stress-ng mergesort
Start N workers that sort 32 bit integers using the BSD mergesort. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:mergesort- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 3.5 – 8.7K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng monte-carlo
Start N stressors that compute <pi> and e (Euler's number) using Monte Carlo computational experiments with various random number generators. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:monte_carlo- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 29.5 – 101.4K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng mpfr
Start N workers that exercise multi-precision floating point operations using the GNU Multi-Precision Floating Point Reliable library (mpfr). The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:mpfr- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 156.8 – 418.6K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng mprotect
Start N workers that exercise changing page protection settings and access memory after each change. 8 processes per worker contend with each other changing page protection settings on a shared memory region of just a few pages to cause TLB flushes. A read and write to the pages can cause segmentation faults and these are handled by the stressor. All combinations of page protection settings are exercised including invalid combinations. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:mprotect- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 39.4K – 37.9M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng mtx
Start N stressors that exercise ISO C mutex locking and unlocking. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:mtx- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,227
- Total measurements
- 4,453
- Range of measurements
- 2.1M – 16.2G ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,453 measurements)
stress-ng munmap
Start N stressors that exercise unmapping of shared non-executable mapped regions of child processes (Linux only). The unmappings map shared memory regions page by page with a prime sized stride that creates many temporary mapping holes. One the unmappings are complete the child will exit and a new one is started. Note that this may trigger segmentation faults in the child process, these are handled where possible by forcing the child process to call _exit. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:munmap- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,227
- Total measurements
- 4,453
- Range of measurements
- 244.4 – 154.3K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,453 measurements)
stress-ng nop
Start N workers that consume cpu cycles issuing no-op instructions. This stressor is available if the assembler supports the "nop" instruction. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:nop- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 33K – 114.4M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng null
Start N workers that exercise /dev/null with write, lseek, ioctl, fcntl, fallocate and fdatasync calls. For just /dev/null write benchmarking use the --null-write option. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:null- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 42.5K – 319M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng pipe
Start N workers that perform large pipe writes and reads to exercise pipe I/O. This exercises memory write and reads as well as context switching. Each worker has two processes, a reader and a writer. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:pipe- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,227
- Total measurements
- 4,453
- Range of measurements
- 67.5K – 266.2M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,453 measurements)
stress-ng powmath
Start N workers that exercise various libm power functions with input values 0 to 1 in steps of 0.001; the results are sanity checked to ensure no variation occurs after each round of 10000 computations. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:powmath- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 137.8 – 622.6K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng prime
Start N workers that find prime numbers using the GNU Multiple Precision Arithmetic Library for large integers. The GMP mpz_nextprime function is used to find primes and it uses a probabilistic algorithm to identify primes, but there is a extremely small chance that the values found are non-prime. The search becomes computationally more expensive over time to find larger and larger primes, hence the bogo-op rate will reduce over time. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:prime- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 52.8K – 120.6M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng priv-instr
Start N workers that exercise various architecture specific privileged instructions that cannot be executed by userspace programs. These instructions will be trapped and processed by SIGSEGV or SIGILL signal handlers. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:priv_instr- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 44.6K – 33.3M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng ptr-chase
Start N workers that chase memory pointers around page sized nodes of pointers. By default each stressor instance allocates 4096 pages of nodes, each node is an array of pointers that are randomly set to point to other node pages. The stressors follow randomly chosen pointers from each node, chasing around the entire node space. This exercises pointer fetching, pointer dereferencing and is a cache-read exercising stressor. The nodes are allocated with 50% of pages from the heap and 50% from mmap'd memory. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:ptr_chase- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 835K – 3.4G ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng qsort
Start N workers that sort 32 bit integers using qsort. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:qsort- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 2.2 – 6K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng resched
Start N workers that exercise process rescheduling. Each stressor spawns a child process for each of the positive niceniceA Unix command that runs a program with a changed scheduling priority, from -20 (highest) to 19 (lowest). Raising a process's priority above the default needs the CAP_SYS_NICE capability, which root has.man pageGlossary levels and iterates over the nice levels from 0 to the lowest priority level (highest nice value). For each of the nice levels 1024 iterations over 3 non-real time scheduling polices SCHED_OTHER, SCHED_BATCH and SCHED_IDLE are set and a sched_yield occurs to force heavy rescheduling activity. When the -v verbose option is used the distribution of the number of yields across the nice levels is printed for the first stressor out of the N stressors. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:resched- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,227
- Total measurements
- 4,453
- Range of measurements
- 13.8K – 107M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,453 measurements)
stress-ng rotate
Start N workers that exercise 1 bit rotates left and right of unsigned integer variables. The default will rotate four 8, 16, 32, 64 (and if supported 128) bit values 10000 times in a loop per bogo-op. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:rotate- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 9K – 35.3M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng skiplist
Start N workers that store and then search for integers using a skiplist. By default, 65536 integers are added and searched. This is a useful method to exercise random access of memory and processor cache. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:skiplist- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 704.6 – 2M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng spinmem
Start N workers that use a shared memory page to keep two processes synchronized using busy spin loops. One process is a writer that increments a value in memory slot 0 and spin waits for the data to appear in memory slot 1. The other process spin waits for the data to change in slot 0 and copies the changed value into memory slot 1. The stressor benchmarks the time for the transactions to occur between both processes. Note that the optimal number of stressors is half the number of online CPUs in a system. By default 32 bit write/reads are used. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:spinmem- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,225
- Total measurements
- 4,428
- Range of measurements
- 0.2 – 180.8K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,428 measurements)
stress-ng str
Start N workers that exercise various libc string functions on random strings. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:str- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 91.6K – 258.2M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng stream
Start N workers exercising a memory bandwidth stressor very loosely based on the STREAM "Sustainable Memory Bandwidth in High Performance Computers" benchmarking tool by John D. McCalpin, Ph.D. This stressor allocates 3 buffers that are at the size of the CPU L3 cache and continually performs rounds of computations on large arrays of double precision floating point numbers. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:stream- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,451
- Range of measurements
- 0.17 – 10M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,451 measurements)
stress-ng switch
Start N workers that force context switching between two mutually blocking/unblocking tied processes. By default message passing over a pipe is used, but different methods are available. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:switch- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,227
- Total measurements
- 4,453
- Range of measurements
- 10.9K – 120.6M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,453 measurements)
stress-ng timermix
Start N workers creating timer and itimer signals at a high rate, this can create a many thousands of timer clock interrupts per second. Each signal that gets handled is counted as a bogo-operation. For timers, the following clocks types (where available) are used: CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID, CLOCK_BOOTTIME and CLOCK_TAI. For itimers, the following interval timer types are used: ITIMER_REAL, ITIMER_VIRTUAL and ITIMER_PROF. Some systems may support none or a subset of these timer or itimer types. The frequency of the itimers is auto-adjusted to try and maximize the timer interrupt rate. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:timermix- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 14K – 197.7M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng tlb-shootdown
Start N workers that force Translation Lookaside Buffer (TLBTLB: Translation Lookaside BufferA CPU cache of recent translations from virtual to physical memory addresses. A TLB shootdown invalidates entries on other cores after a mapping changes, which needs an interrupt to each of them.WikipediaGlossary) shootdowns. This is achieved by creating up to 16 child processes that all share a region of memory and these processes are shared amongst the available CPUs. The processes adjust the page mapping settings causing TLBs to be force flushed on the other processors, causing the TLB shootdowns. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:tlb_shootdown- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 617 – 609.3K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng tree
Start N workers that exercise tree data structures. The default is to add, find and remove 250000 64 bit integers into AVL (avl), Red-Black (rb), Splay (splay), btree and binary trees. The intention of this stressor is to exercise memory and cache with the various tree operations. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:tree- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,225
- Total measurements
- 4,448
- Range of measurements
- 0.2 – 307 ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,448 measurements)
stress-ng trig
Start N workers that exercise sin, cos, sincos (where available) and tan libm trigonometric functions using float, double and long double floating point variants. Each function is exercised 10000 times per bogo-operation. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:trig- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 175.2 – 703.7K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng tsc
Start N workers that read the Time Stamp Counter (TSC) 256 times per loop iteration (bogo operation). This exercises the tsc instruction for x86, the mftb instruction for ppc64, the rdcycle instruction for RISC-V, the tick instruction on SPARC and the rdtime.d instruction for Loong64. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:tsc- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,019
- Total measurements
- 4,038
- Range of measurements
- 80.4K – 372M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,038 measurements)
stress-ng usersyscall
Start N workers that exercise the Linux prctl userspace system call mechanism. A userspace system call is handled by a SIGSYS signal handler and exercised with the system call disabled (ENOSYS) and enabled (via SIGSYS) using prctl PR_SET_SYSCALL_USER_DISPATCH. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:usersyscall- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,019
- Total measurements
- 4,038
- Range of measurements
- 36.5K – 32.9M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,038 measurements)
stress-ng vdso
Start N workers that repeatedly call each of the system call functions in the vDSO (virtual dynamic shared object). The vDSO is a shared library that the kernel maps into the address space of all user-space applications to allow fast access to kernel data to some system calls without the need of performing an expensive system call. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:vdso- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,229
- Total measurements
- 4,458
- Range of measurements
- 5.1M – 38.7G ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,458 measurements)
stress-ng veccmp
Start N workers that perform various unsigned integer math comparison operations on various 128 bit vectors. A mix of integer vector comparison operations are performed on the following vectors: 16 x 8 bits, 8 x 16 bits, 4 x 32 bits, 2 x 64 bits and if supported 1 x 128 bits. The metrics produced by this mix depend on the processor architecture and the vector math optimisations produced by the compiler. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:veccmp- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 1.9K – 5.6M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng vecfp
Start N workers that exercise floating point (single and double precision) addition, multiplication, division and negation on vectors of 128, 64, 32, 16 and 8 floating point values. The -v option will show the approximate throughput in millions of floating pointer operations per second for each operation. For x86, the gcc/clang target clones attribute has been used to produced vector optimizations for a range of mmx, sse, avx and processor features. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:vecfp- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 168.6 – 449.7K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng vecmath
Start N workers that perform various unsigned integer math operations on various 128 bit vectors. A mix of vector math operations are performed on the following vectors: 16 x 8 bits, 8 x 16 bits, 4 x 32 bits, 2 x 64 bits and where supported 1 x 128 bits. The metrics produced by this mix depend on the processor architecture and the vector math optimisations produced by the compiler. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:vecmath- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 402.6 – 1.1M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng vecshuf
Start N workers that shuffle data on various 64 byte vectors comprised of 8, 16, 32, 64 and 128 bit unsigned integers. The integers are shuffled around the vector with 4 shuffle operations per loop, 65536 loops make up one bogo-op of shuffling. The data shuffling rates and shuffle operation rates are logged when using the -v option. This stressor exercises vector load, shuffle/permute, packing/unpacking and store operations. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:vecshuf- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 63 – 839.2K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng vecwide
Start N workers that perform various 8 bit math operations on vectors of 4, 8, 16, 32, 64, 128, 256, 512, 1024 and 2048 bytes. With the -v option the relative compute performance vs the expected compute performance based on total run time is shown for the first vecwide worker. The vecwide stressor exercises various processor vector instruction mixes and how well the compiler can map the vector operations to the target instruction set. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:vecwide- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,226
- Total measurements
- 4,452
- Range of measurements
- 2.8K – 12.9M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng vfork
Start N workers continually vforking children that immediately exit. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:vfork- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,227
- Total measurements
- 4,452
- Range of measurements
- 1.9K – 630.4K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,452 measurements)
stress-ng vm
Start N workers continuously calling mmap/munmap and writing to the allocated memory. Note that this can cause systems to trip the kernel OOM killerout-of-memory killerThe Linux kernel mechanism that frees memory when the system, or a cgroup, runs out of it and cannot reclaim enough. It picks a process by a badness score, mostly based on its memory use, and kills it. Container runtimes rely on it to enforce memory limits.Linux kernel docsGlossary on Linux systems if not enough physical memory and swap is not available. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:vm- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,222
- Total measurements
- 4,413
- Range of measurements
- 293.1 – 7M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,413 measurements)
stress-ng wcs
Start N workers that exercise various libc wide character string functions on random strings. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:wcs- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,228
- Total measurements
- 4,456
- Range of measurements
- 65K – 153.3M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,456 measurements)
stress-ng x86syscall
Start N workers that repeatedly exercise the x86-64 syscall instruction to call the getcpu, geteuid, getgid, getpid, gettimeofday and time system calls using the Linux vsyscall handler. Only for Linux. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:x86syscall- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,019
- Total measurements
- 4,038
- Range of measurements
- 508.5K – 3.9G ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,038 measurements)
stress-ng yield
Start N workers that call sched_yield. This stressor ensures that at least 2 child processes per CPU exercise sched_yield no matter how many workers are specified, thus always ensuring rapid context switching. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:yield- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,225
- Total measurements
- 4,438
- Range of measurements
- 226.3K – 692.4M ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,438 measurements)
stress-ng zero
Start N workers that exercise /dev/zero with read, lseek, ioctl and mmap calls. For just /dev/zero read benchmarking use the --zero-read option. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:zero- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,228
- Total measurements
- 4,456
- Range of measurements
- 335K – 2.3G ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,456 measurements)
stress-ng zlib
Start N workers compressing and decompressing random data using zlib. Each worker has two processes, one that compresses random data and pipes it to another process that decompresses the data. This stressor exercises CPU, cache and memory. The score is the total bogo operations per second (in real time) based on wall clock run time.
Benchmark details
- Benchmark ID
stress_ng:zlib- Unit of measurement
- Bogo operations per second (ops/s)
- Server types evaluated
- 2,222
- Total measurements
- 4,433
- Range of measurements
- 0.2 – 20.3K ops/s
- Better
- ↑ Higher is better
Configuration options
| Field | Description | Example values |
|---|---|---|
cores | Single-Core or Multi-Core stress tests. | multi single |
Score distribution (4,433 measurements)