# Glossary

> The terms used in the docs of the benchmark-storage image.

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

## B {#letter-b}

### `blkdiscard` {#blkdiscard}

A Linux command from util-linux that discards (trims) a range of blocks, by default all blocks of a device, and so deletes their data. An SSD then treats those blocks as unwritten and can erase them in the background, which restores the write speed of a fresh drive. See [man page](https://man7.org/linux/man-pages/man8/blkdiscard.8.html).

## C {#letter-c}

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

## D {#letter-d}

### DRAM {#dram}

**Dynamic Random-Access Memory**: The most common type of volatile computer memory, which stores each bit as a charge in a capacitor that has to be refreshed periodically. Servers use it as main memory, and many storage devices as a cache. See [Wikipedia](https://en.wikipedia.org/wiki/Dynamic_random-access_memory).

## F {#letter-f}

### `fio` {#benchmark-storage-fio}

The Flexible I/O Tester, an open-source storage benchmark and I/O workload generator. Each job describes an access pattern, such as random or sequential reads and writes, the block size, the queue depth, and the I/O engine, and `fio` reports the resulting IOPS, bandwidth, and latency. See [fio docs](https://fio.readthedocs.io/en/latest/).

### FTL {#benchmark-storage-ftl}

**Flash Translation Layer**: The firmware layer of an SSD controller that maps the logical blocks the host sees to physical flash pages. Because flash has to be erased in large blocks before it is rewritten, the FTL writes new data to free pages, and runs garbage collection and wear leveling in the background. [Wikipedia](https://en.wikipedia.org/wiki/Flash_memory_controller#Flash_translation_layer_(FTL)_and_mapping).

## G {#letter-g}

### garbage collection {#benchmark-storage-garbage-collection}

The background work in which an SSD frees flash for new writes. Flash can only be erased in large blocks, so the drive copies the still-valid pages out of a block, then erases the whole block. It runs when spare area runs low, and it slows the writes that arrive meanwhile, which is why an SSD's sustained write speed is lower than its burst speed. Programming languages use the same term for reclaiming unused memory. See [Wikipedia](https://en.wikipedia.org/wiki/Garbage_collection_%28SSD%29).

### GCP {#gcp}

**Google Cloud Platform**: The cloud computing platform of Google. It offers virtual machines (Compute Engine), object storage, managed databases, Kubernetes and machine learning services, among others. See [Google Cloud](https://cloud.google.com/).

## H {#letter-h}

### HDD {#hdd}

**Hard Disk Drive**: A storage device that reads and writes data with magnetic heads on spinning platters. It offers cheap capacity, but each random access waits for a head to move and a platter to turn, so it completes far fewer random operations per second than an SSD. See [Wikipedia](https://en.wikipedia.org/wiki/Hard_disk_drive).

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

### ID {#id}

**identifier**: A name or number that refers to exactly one item, such as a server type, a benchmark run, or a database row.

### IOPS {#iops}

**Input/Output Operations Per Second**: The number of read and write operations a storage device completes per second. It is the main measure of random-access performance, and depends on the block size, the queue depth and the mix of reads and writes. See [Wikipedia](https://en.wikipedia.org/wiki/IOPS).

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

## L {#letter-l}

### LLM inference speed {#llm-inference-speed}

How fast hardware runs an LLM, usually measured in tokens per second. It is measured separately for prompt processing, in which the model reads the input prompt, and text generation, in which it produces output tokens one at a time, because the first is usually limited by compute and the second by memory bandwidth. Benchmarks of LLM servers also measure latency, such as the time to first token, and the throughput of many concurrent requests.

### LVM {#lvm}

**Logical Volume Manager**: The Linux tool that pools disks or partitions into volume groups and divides these into logical volumes, which can be resized while in use. It also supports snapshots, and striping or mirroring across disks. See [man page](https://man7.org/linux/man-pages/man8/lvm.8.html).

## N {#letter-n}

### NVMe {#nvme}

**Non-Volatile Memory Express**: The interface specification for accessing non-volatile storage, most often SSDs, over PCI Express. It is designed for the parallelism of flash memory, with many deep command queues, and NVMe over Fabrics extends it to network transports. See [NVM Express](https://nvmexpress.org/).

## O {#letter-o}

### OVHcloud {#ovhcloud}

A French cloud provider, founded in 1999, with data centers in Europe, North America and Asia-Pacific. It offers dedicated (bare-metal) servers, public cloud instances based on OpenStack, and private cloud. See [OVHcloud](https://www.ovhcloud.com/).

## P {#letter-p}

### PID {#pid}

**Process Identifier**: The number by which the operating system identifies a running process. On Linux, a PID is assigned when a process starts and can be reused after it exits, and commands such as kill use it to target a process. See [Wikipedia](https://en.wikipedia.org/wiki/Process_identifier).

## R {#letter-r}

### RAID {#raid}

**Redundant Array of Independent Disks**: A way to combine several disks into one logical device, for redundancy, speed or both. Common levels are RAID 0 (striping), RAID 1 (mirroring) and RAID 5 or 6 (striping with parity); on Linux, the `md` driver implements RAID in software. See [Wikipedia](https://en.wikipedia.org/wiki/RAID).

### RAM {#ram}

**Random-Access Memory**: The main memory of a computer, which holds the running programs and their data. It is much faster than disk storage, and its content is lost when the power is off. See [Wikipedia](https://en.wikipedia.org/wiki/Random-access_memory).

## S {#letter-s}

### SLC {#benchmark-storage-slc}

**Single-Level Cell**: Flash memory that stores one bit per cell, which makes it faster and more durable than flash storing more bits per cell, such as TLC or QLC. Many SSDs run part of their flash in SLC mode as a write cache, and write more slowly once a long write fills it. See [Wikipedia](https://en.wikipedia.org/wiki/Multi-level_cell).

### SMART {#smart}

**Self-Monitoring, Analysis, and Reporting Technology**: A monitoring system built into HDDs and SSDs that records health and error counters, such as reallocated sectors, power-on hours or wear level. Tools such as `smartctl` read these counters to spot failing disks early. See [Wikipedia](https://en.wikipedia.org/wiki/Self-Monitoring,_Analysis_and_Reporting_Technology).

### `smartctl` {#smartctl}

The command-line tool of the smartmontools package that reads SMART data, self-test logs and device information from ATA, SCSI and NVMe disks, and can start self-tests. See [smartmontools](https://www.smartmontools.org/).

### SSD {#ssd}

**Solid-State Drive**: A storage device that keeps data in flash memory instead of on spinning disks, so it reads and writes much faster than an HDD, especially at random locations. A controller with its own firmware maps logical blocks to flash pages, and many SSDs write incoming data to a fast cache first, then move it to slower flash. Cloud servers use SSDs as local disks and behind network block storage. See [Wikipedia](https://en.wikipedia.org/wiki/Solid-state_drive).

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

## U {#letter-u}

### UTC {#utc}

**Coordinated Universal Time**: The primary time standard by which the world sets its clocks, the successor of Greenwich Mean Time. It has no time zone offset or daylight saving time, so UTC timestamps compare directly across regions. See [Wikipedia](https://en.wikipedia.org/wiki/Coordinated_Universal_Time).

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

## Z {#letter-z}

### `zram` {#zram}

A Linux kernel module that creates compressed block devices in memory. It is most often used as swap, so swapped-out pages are compressed in RAM instead of written to disk, trading CPU time for memory. See [Linux kernel docs](https://docs.kernel.org/admin-guide/blockdev/zram.html).
