Glossary

75 terms, in the sense this mechanism uses them. The platform glossary has every term across all mechanisms.

Actuator: The moving arm that positions a hard disk's head.
Air gap: Physical separation of data from any network, e.g. a tape cartridge on a shelf.
Amdahl's Law: Speedup limit for a fixed-size job with serial fraction s: maximum = 1/s.
Amortization: Spreading a fixed cost over many units so the cost per unit falls.Paying a fixed cost once and spreading it over many units. One delivery truck for 1,000 parcels costs less per parcel than 1,000 bicycles.
Amplification: Extra bytes read, written or stored compared with what was logically needed.If you ask for 200 bytes and the system must move 4,096 bytes, the amplification is about 20. Read amplification means extra bytes read. Write amplification means extra bytes written. Space amplification means extra bytes stored. It is the hidden cost behind most slow systems.
Arithmetic intensity: FLOPs done per byte moved from memory; the x-axis of the roofline.
Arrhenius relation: Retention time grows exponentially with barrier height divided by temperature.
AZ (Availability Zone): An isolated datacenter (or group) inside a cloud region.A rack is a cabinet of servers that share one network switch and one power feed. An AZ is a separate datacenter building (or group) inside a cloud region. Things in the same rack or AZ tend to fail together.
Bandwidth: Bytes (or bits) moved per second.Latency is how long one operation takes before the first byte arrives. Bandwidth (also throughput) is how many bytes arrive per second after that. A truck driving 500 km has a high latency (many hours) and may still carry a huge amount: high bandwidth.
Batching: Handling many records per operation to spread a fixed cost; a batch fails as a unit.Doing many small things as one bigger operation, to pay a setup cost only once. Carrying all the shopping in one trip instead of one item per trip.
BDP (bandwidth-delay product): Bandwidth × RTT: the data that must be in flight to fill a link.
Bisection bandwidth: Worst-case throughput across a cut that divides a network in two.
Bloom filter: A bit array and k hash functions answering "definitely not present" or "probably present"A tiny structure that answers "is this key in the set?" with either "definitely not" or "probably yes". It never misses a real member, but sometimes says "probably yes" for a key that is not there (a false positive). It needs about 10 bits per key.
Branch prediction: The CPU guessing which way an if goes, to keep its pipeline full.
Bufferbloat: Excess latency caused by large buffers that stay full, with no gain in throughput.
Cache coherence: The hardware rule that keeps copies of one memory location in different cores' caches consistent; works per cache line.
Cache line: The 64-byte block the CPU moves between RAM and cache.Memory (RAM) is fast but small and loses its content when power is off. Storage (SSD, disk) is slower but large and permanent. Hardware never moves single bytes. It moves fixed-size blocks:
Compaction: Rewriting many small files into fewer larger ones.An LSM-tree (Log-Structured Merge tree) is a storage structure that never changes files in place. It collects writes in memory, writes them as sorted, immutable files, and later compacts (merges and rewrites) the files in the background to remove old versions and deleted entries. A tombstone is a marker that says "this key was deleted"; compaction removes the key and the marker. Compaction costs disk and CPU. Write amplification is the ratio of bytes the storage actually writes to bytes the application asked to write. A Bloom filter is a small structure that answers "definitely not in this file" or "maybe in this file", so reads can skip most files.
Congestion control: Algorithms (Reno, CUBIC, BBR) by which senders find and share network capacity.
Context switch: The OS pausing one thread and resuming another.
cwnd: TCP congestion window: how much unacknowledged data a sender may have in flight.
DPDK: Data Plane Development Kit: user-space packet processing that skips the kernel.
DRAM: Dynamic RAM: capacitor-based main memory that needs refreshing.
ECMP: Equal-Cost Multi-Path: choosing a network path by hashing flows.
Endurance: How many write/erase cycles a storage cell survives.
False sharing: Two cores writing different variables in the same cache line, so the line bounces between caches.
FTL (flash translation layer): An SSD's mapping from logical to physical addresses.An SSD cannot overwrite a small piece of data in place. Its internal software, the FTL (flash translation layer), writes new data to a fresh place, keeps a lookup table, and later cleans old data, which means one logical write can cause several physical writes (typically 2 to 3 times, sometimes more).
Garbage collection (GC): Runtime component that finds unreachable objects and reclaims their memory.In Java, Go, C# and similar languages you never call free. A background component, the garbage collector, finds objects that nothing refers to any more and reclaims their memory. A tracing collector does this by starting from known roots (variables) and following every reference to mark the objects that are still live. The live set is the total size of all live objects. A generational collector splits the heap into a young generation (new objects, collected often and cheaply) and an old generation (objects that survived several collections). Pauses are moments when the program is stopped so the collector can work.
Granularity: The smallest increment a mechanism handles or bills.The smallest piece a mechanism handles. If a courier charges per whole kilogram, one kilogram is the granularity, even if you ship 100 grams. When what you need is smaller than the granularity, you pay for the difference. This mechanism calls that difference granularity waste.
Gustafson's Law: Speedup when problem size grows with the number of processors.
HDD: Hard disk drive: spinning magnetic platters.
Huge pages: 2 MB virtual-memory pages that extend TLB reach by ~500×.
Incast: Synchronized many-to-one traffic that overflows a switch buffer and causes timeouts.
Indirection: An extra lookup layer between a name and a physical location.A lookup layer between "the name you use" and "where the thing really is", like a phone book or a URL redirect. It lets you move things without telling everyone.
io_uring: Linux asynchronous I/O interface that submits many requests with few kernel calls.
IOPS: I/O operations per second."I/O operations per second": how many separate read or write requests a device finishes each second. A device has two speed limits: requests per second (IOPS) and bytes per second (bandwidth).
Kingman's formula: Approximation of queue waiting time: utilization and variability multiply.
Latency: Time one operation takes from request to response.Throughput is work finished per second. Latency is how long one operation takes. Little's Law links them to the number of operations in progress: L = λ × W, where λ is the arrival rate (per second), W is the average time one operation spends in the system, and L is how many are inside the system at the same time. Example: 1,000 requests per second, each taking 20 ms (0.02 s), means 1,000 × 0.02 = 20 requests in flight at any moment. This is an identity, not a design choice.
Little's Law: L = λW: average items in a system = arrival rate × average time in the system.Throughput is work finished per second. Latency is how long one operation takes. Little's Law links them to the number of operations in progress: L = λ × W, where λ is the arrival rate (per second), W is the average time one operation spends in the system, and L is how many are inside the system at the same time. Example: 1,000 requests per second, each taking 20 ms (0.02 s), means 1,000 × 0.02 = 20 requests in flight at any moment. This is an identity, not a design choice.
LSM-tree: Log-structured merge tree: buffer writes in memory, flush sorted runs, merge in the background.An LSM-tree (Log-Structured Merge tree) is a storage structure that never changes files in place. It collects writes in memory, writes them as sorted, immutable files, and later compacts (merges and rewrites) the files in the background to remove old versions and deleted entries. A tombstone is a marker that says "this key was deleted"; compaction removes the key and the marker. Compaction costs disk and CPU. Write amplification is the ratio of bytes the storage actually writes to bytes the application asked to write. A Bloom filter is a small structure that answers "definitely not in this file" or "maybe in this file", so reads can skip most files.
Memory: Memory (RAM) is fast but small and loses its content when power is off. Storage (SSD, disk) is slower but large and permanent. Hardware never moves single bytes. It moves fixed-size blocks:
MTU: Maximum transmission unit: largest network packet (1,500 B standard, 9,000 B jumbo).
NAND flash: Non-volatile memory in SSDs; erased per block, written per page.
NUMA: Non-uniform memory access: memory attached to another socket is slower to reach.On a server with several CPU sockets, each socket has its own directly attached memory. Reading another socket's memory (remote access) is slower than reading your own (local access). The name is Non-Uniform Memory Access.
NVMe: Protocol for fast, highly parallel SSD access over PCIe.
Over-provisioning: Hidden spare capacity in an SSD that lowers write amplification.
p99: The latency that 99% of requests beat; shows the slow tail.Time 1,000 requests and sort them from fastest to slowest. The p50 (median) is the 500th: half were faster. The p99 is the 990th: only 1% were slower. The p99.9 is the 999th. The slowest requests are called the tail. The mean (average) adds all the times and divides by the count.
Page: The fixed-size unit (commonly 4-16 KiB) read and written by storage and databases.3 other meanings →Storage hardware and databases do not read single bytes. They read fixed-size chunks called pages (or blocks), typically 4 KiB to 16 KiB on a local disk. To read one 200-byte row you must read its whole page.
Percentile (p50, p99, p99.9): The value below which that fraction of observations fall.p50 is the median latency, p99 is the latency that 99% of requests beat. The slowest requests are the tail. When one request needs answers from many servers (a fan-out) it must wait for the slowest one. With 100 servers that each have a 1% chance of being slow, the chance that at least one is slow is 1 − 0.99¹⁰⁰ = 63%. So the user-facing tail is much worse than any single server's tail.
Prefetcher: Hardware that loads memory it predicts you will need next.
Queue: A line of work waiting for its turn, like people waiting at a bank counter. A scheduler is the part of a system that decides who is served next.1 other meaning →
Quorum: A majority of replicas.A quorum is a group of nodes big enough that its answer counts. The usual quorum is a majority: more than half. With 5 nodes, any 3 form a majority. The key fact: any two majorities of the same set share at least one member. Why? If two groups of 3 from 5 nodes had no member in common, they would need 6 different nodes, but there are only 5. This is the pigeonhole principle. It is arithmetic; it uses no clock and holds however slow the network is. We use it again and again.
RDMA: Remote Direct Memory Access: reading/writing another machine's memory without using its CPU.
Roofline model: Plot of achievable performance vs. arithmetic intensity, showing memory-bound and compute-bound regions.
Rto: TCP retransmission timeout: the fallback timer after packet loss.1 other meaning →
RTT (round-trip time): Round-trip time.Machines talk by sending messages over a network. A message may be late, may arrive twice, may arrive out of order, or may never arrive. The round-trip time (RTT) is the time from sending a request until the reply returns. RTT depends strongly on distance:
RUM conjecture: The claim that Read, Update and Memory cost cannot all be optimized together; unproven.
Server: A queue is a line of work waiting its turn, like people waiting at a bank counter. A "server" here means anything that does work: a disk, a CPU core, a thread, a database connection.
Shared-nothing: Architecture where each partition owns its data and CPU and shares no state.
Shuffle: Moving rows between stages so that data is partitioned by a different key.Two stages of a parallel query often need the data grouped by different keys. The shuffle moves every row from the machine that produced it to the machine that needs it. It is the most expensive data movement in a distributed engine.
SIMD: Single Instruction, Multiple Data: one instruction on many values.
Slow start: TCP's initial exponential probing of available bandwidth.
SMR: Shingled Magnetic Recording: overlapping tracks for density; needs sequential zone writes.
SRAM: Static RAM: fast, power-held memory used in CPU caches.
Storage: Memory (RAM) is fast, small, and forgets everything when power is off (volatile). Storage (disk, SSD) is slower, bigger, and remembers (non-volatile or persistent).
Tail latency: Latency of the slowest requests (p99 and beyond).To query a dataset split over many machines (shards), a coordinator sends the query to the shards (scatter) and merges the answers (gather). The query is finished only when the slowest shard answers, so the latency of the whole is the maximum over shards. Slow outliers (the "tail", measured by percentiles such as p99, the time that 99% of requests beat) therefore hurt more as you add shards.
Throughput: Work completed per unit of time.Throughput is work finished per second. Latency is how long one operation takes. Little's Law links them to the number of operations in progress: L = λ × W, where λ is the arrival rate (per second), W is the average time one operation spends in the system, and L is how many are inside the system at the same time. Example: 1,000 requests per second, each taking 20 ms (0.02 s), means 1,000 × 0.02 = 20 requests in flight at any moment. This is an identity, not a design choice.
TLB: Translation Lookaside Buffer: CPU cache of virtual-to-physical address translations.
TRIM: Command telling an SSD which logical addresses no longer hold live data.
TTFB: Time to first byte.
Units of data: A byte (B) is about one character. KB, MB, GB, TB are about a thousand, a million, a billion and a trillion bytes. A bit is 1/8 of a byte. Network speed is usually quoted in bits (Gb/s), storage in bytes. Divide by 8 to convert: a 10 Gb/s link moves at most 1.25 GB/s.
USL: Scalability model with contention (α) and coherency (β) terms; predicts a throughput peak and then decline.
Utilization (ρ): The fraction of time a resource is busy.Utilization (ρ, "rho") is the fraction of time a server is busy. For random arrivals, average response time grows like S ÷ (1 − ρ), where S is the service time: 2×S at 50%, 5×S at 80%, 10×S at 90%, 100×S at 99%. Queues are caused by variability meeting load, and the curve has a wall at 100%. The last few percent of utilization cost more than the first eighty.
WAF: Write amplification factor: physical writes ÷ logical writes.
Zero-copy: Sending stored bytes to a socket without copying them through user space.1 other meaning →