# Glossary

> The terms used in the docs of the stress-ng image.

Acronyms and terms used on this image's pages. See the [site-wide glossary](https://docs.sparecores.com/glossary.md) for all terms.

## A {#letter-a}

### AMD64 {#amd64}

The 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`. See [Wikipedia](https://en.wikipedia.org/wiki/X86-64).

## C {#letter-c}

### container entrypoint {#container-entrypoint}

The executable that a container image runs when a container starts, set by the `ENTRYPOINT` instruction of its Dockerfile. The image's default command (`CMD`), or the arguments given after the image name in `docker run`, are passed to it as arguments, so an entrypoint can wrap any command, for example to set up the environment or record resource usage first. The `docker run --entrypoint` option replaces it. See [Dockerfile reference](https://docs.docker.com/reference/dockerfile/#entrypoint).

### CPU {#cpu}

**Central Processing Unit**: The 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. See [Wikipedia](https://en.wikipedia.org/wiki/Central_processing_unit).

### CPU-credit throttling {#cpu-credit-throttling}

A limit on burstable cloud server types, which earn CPU credits while they run below a baseline CPU usage and spend them to run above it. When the credits run out, the provider throttles the server to its baseline, so sustained load runs slower than a short burst. See [AWS burstable instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html).

## I {#letter-i}

### I/O {#i-o}

**Input/Output**: The transfer of data between a computer and the outside world, such as reading and writing disks or sending and receiving network packets. A workload limited by its speed rather than by the CPU is called I/O-bound. See [Wikipedia](https://en.wikipedia.org/wiki/Input/output).

## J {#letter-j}

### JSON {#json}

**JavaScript Object Notation**: A text format for structured data, built from objects (key-value pairs), arrays, strings, numbers, booleans, and null. Most languages and tools read and write it, which makes it a common format for API responses and benchmark output. See [JSON](https://www.json.org/).

## N {#letter-n}

### nested paging {#nested-paging}

Hardware support for memory virtualization, in which the CPU translates a guest's virtual addresses through the guest's page tables and then through a second set of page tables kept by the hypervisor. It removes the need for the hypervisor to maintain shadow page tables, but a TLB miss then needs more memory lookups. Intel calls it Extended Page Tables and AMD Rapid Virtualization Indexing. See [Wikipedia](https://en.wikipedia.org/wiki/Second_Level_Address_Translation).

### `nice` {#nice}

A 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. See [man page](https://man7.org/linux/man-pages/man1/nice.1.html).

## P {#letter-p}

### `psutil` {#psutil}

A cross-platform Python library for retrieving information on running processes and system utilization, such as CPU, memory, disks, and network. It can count both logical CPUs and physical cores. See [psutil docs](https://psutil.readthedocs.io/).

## R {#letter-r}

### `resource-tracker` {#resource-tracker}

An open-source Spare Cores tool that runs a command and samples resource usage while it runs, such as CPU, memory, disk, network, GPU, and GPU memory use. It can optionally stream the samples to the Spare Cores Sentinel platform, so that a run can be checked to see its aggregated and detailed resource utilization, e.g., whether it used all CPU or GPU cores as intended while running a Navigator benchmark workload. See [resource-tracker on GitHub](https://github.com/SpareCores/resource-tracker-rs).

## S {#letter-s}

### SCore {#score}

**Spare Cores score**: A CPU speed score of a server type in Spare Cores Navigator, used to compare the speed of server types. It is measured with the `cpu` stressor of `stress-ng` at increasing worker counts. The single-core SCore is the result with one worker; the multi-core SCore, the raw multi-core CPU speed that SCore means on its own, is the highest result.

### shared-core {#shared-core}

Describes a cloud server type whose vCPUs share physical cores with other servers, often with a guaranteed baseline of only a fraction of a core. Such server types are cheaper, but their CPU performance can vary with the load of neighboring servers or be limited by CPU credits. See [Google Cloud shared-core machine types](https://cloud.google.com/compute/docs/general-purpose-machines#sharedcore).

### SIMD {#simd}

**Single Instruction, Multiple Data**: A form of parallel processing in which one CPU instruction applies the same operation to several data elements at once. CPUs implement it with vector instruction set extensions, which x86 and Arm CPUs both provide. See [Wikipedia](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data).

### SMT {#smt}

**Simultaneous Multithreading**: A CPU technique that runs two (or more) hardware threads on one physical core, sharing its execution units, e.g. Intel Hyper-Threading. It raises throughput when a thread stalls, but the threads compete for the core. Cloud vendors usually sell each thread as a vCPU. See [Wikipedia](https://en.wikipedia.org/wiki/Simultaneous_multithreading).

### stderr {#stderr}

The standard error stream of a process, one of the three standard streams with stdin and stdout. Programs write logs, progress, and error messages to it, so that they stay separate from the output on stdout when the output is redirected to a file or another program. See [Wikipedia](https://en.wikipedia.org/wiki/Standard_streams).

### stdout {#stdout}

The standard output stream of a process, one of the three standard streams with stdin and stderr. Programs write their results to it; a shell can redirect it to a file or another program, such as `> results.jsonl`, while logs on stderr still reach the terminal. See [Wikipedia](https://en.wikipedia.org/wiki/Standard_streams).

### `stress-ng` {#stress-ng}

An 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. See [stress-ng on GitHub](https://github.com/ColinIanKing/stress-ng).

### stress-ng bogo ops/s {#stress-ng-stress-ng-bogo-ops-s}

**bogus operations per second**: The throughput metric of `stress-ng`: how many times a stressor completes its own unit of work per second. Each stressor defines that unit differently, so the values compare only within one stressor and one `stress-ng` version. See [stress-ng man page](https://manpages.ubuntu.com/manpages/noble/man1/stress-ng.1.html).

### stress-ng div16 method {#stress-ng-stress-ng-div16-method}

A method of the `stress-ng` `cpu` stressor, selected with `--cpu-method div16`, in which each operation runs 50,000 16-bit unsigned integer divisions. Integer division takes many CPU cycles and depends little on memory, so it loads the core's arithmetic units directly. See [stress-ng man page](https://manpages.ubuntu.com/manpages/noble/man1/stress-ng.1.html).

### stress-ng metrc line {#stress-ng-stress-ng-metrc-line}

A line in which `stress-ng --metrics` prints a stressor's results when the run ends, tagged `metrc`: the bogo ops count, the real, user, and system time, and the bogo ops/s, among other columns. See [stress-ng man page](https://manpages.ubuntu.com/manpages/noble/man1/stress-ng.1.html).

### stress-ng stressor {#stress-ng-stress-ng-stressor}

One stress test of `stress-ng`, such as `cpu`, `memcpy`, or `fork`, selected with a command-line option of the same name and run by one or more worker processes. See [stress-ng man page](https://manpages.ubuntu.com/manpages/noble/man1/stress-ng.1.html).

## T {#letter-t}

### TLB {#tlb}

**Translation Lookaside Buffer**: A 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. See [Wikipedia](https://en.wikipedia.org/wiki/Translation_lookaside_buffer).

## V {#letter-v}

### vCPU {#vcpu}

**virtual CPU**: A 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. See [Wikipedia](https://en.wikipedia.org/wiki/Virtual_CPU).

### VM {#vm}

**virtual machine**: A computer emulated in software on a physical host, with its own OS and a share of the host's CPUs, memory, and storage. Most cloud servers are VMs. See [Wikipedia](https://en.wikipedia.org/wiki/Virtual_machine).

### VM exit {#vm-exit}

A transition from a virtual machine's guest code to the hypervisor, triggered by an operation the hypervisor has to handle, such as some privileged instructions, I/O, or interrupts. Each exit and return costs CPU time, so workloads that cause many exits run slower in a VM.
