# Glossary

> The terms used in the docs of the benchmark-pgbench-postgres 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}

### AWS {#aws}

**Amazon Web Services**: The cloud computing platform of Amazon, launched in 2006 and the largest public cloud by market share. It offers hundreds of services, from virtual machines (EC2) and object storage (S3) to managed databases and machine learning. See [AWS](https://aws.amazon.com/).

## B {#letter-b}

### BenchBase {#benchmark-pgbench-postgres-benchbase}

A framework that benchmarks SQL databases, the successor to OLTPBench. It runs workloads such as YCSB and a Wikipedia workload against any relational database with a JDBC (Java Database Connectivity) driver, and collects per-transaction-type latency and throughput logs. See [GitHub](https://github.com/cmu-db/benchbase).

### BRIN {#benchmark-pgbench-postgres-brin}

**Block Range Index**: A PostgreSQL index type that stores only a summary, such as the minimum and maximum value, of each range of consecutive table blocks. It is tiny compared to a B-tree, and works well on large tables whose values follow their physical order, such as timestamps of appended rows. See [PostgreSQL docs](https://www.postgresql.org/docs/current/brin.html).

## C {#letter-c}

### CDN {#cdn}

**Content Delivery Network**: A network of distributed servers that cache content, such as web pages, images or video, and serve it from locations close to its users. It lowers latency for the users and offloads traffic from the origin server. See [Wikipedia](https://en.wikipedia.org/wiki/Content_delivery_network).

### concurrency points {#benchmark-pgbench-postgres-concurrency-points}

The client counts at which a database benchmark measures throughput and latency, each with that number of connections open for a fixed time. Measuring several concurrency points, from one client up to a count derived from the server's size, shows how throughput and latency change with load.

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

### CV {#cv}

**Coefficient of Variation**: The standard deviation of a set of measurements divided by their mean, often given as a percentage. As it is scale-free, it compares the variability of measurements of different magnitudes, such as how much repeated runs of different benchmarks vary. See [Wikipedia](https://en.wikipedia.org/wiki/Coefficient_of_variation).

## D {#letter-d}

### DBaaS {#dbaas}

**Database as a Service**: A cloud service model in which the vendor runs a database for its users, handling provisioning, backups, patching and replication. Examples are Amazon RDS and Google Cloud SQL. See [Wikipedia](https://en.wikipedia.org/wiki/Cloud_database).

## G {#letter-g}

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

### GIN {#benchmark-pgbench-postgres-gin}

**Generalized Inverted Index**: A PostgreSQL index type that maps each element of a composite value, such as an array item, a key of a JSON document, or a word of a text, to the rows that contain it. It speeds up containment and full-text searches, at the cost of slower writes than a B-tree. See [PostgreSQL docs](https://www.postgresql.org/docs/current/gin.html).

### GUC {#benchmark-pgbench-postgres-guc}

**Grand Unified Configuration**: The configuration system of PostgreSQL, and by extension its individual settings, such as `shared_buffers` or `work_mem`. A setting can be set in `postgresql.conf`, on the command line, per database or role, or per session with `SET`. See [PostgreSQL docs](https://www.postgresql.org/docs/current/config-setting.html).

## H {#letter-h}

### HammerDB {#benchmark-pgbench-postgres-hammerdb}

An open-source database benchmark engine. It runs standardized workloads, such as TPROC-C, with the same test definitions on SQL Server, Db2, Oracle, PostgreSQL, MariaDB, and MySQL, so that results are comparable across database systems. Runs can be scripted and repeated automatically. See [HammerDB](https://www.hammerdb.com/).

### harness {#harness}

The code that runs a benchmark tool. It prepares the inputs, starts the tool with fixed settings, often several times or in parallel, checks and collects the tool's output, and prints the results in one format. Its settings, not the tool's defaults, decide what the benchmark measures. See [Wikipedia](https://en.wikipedia.org/wiki/Test_harness).

### HTTPS {#https}

**Hypertext Transfer Protocol Secure**: HTTP, the protocol of the web, encrypted with TLS. It protects requests and responses from eavesdropping and tampering, and its certificates let clients verify the identity of the server. See [Wikipedia](https://en.wikipedia.org/wiki/HTTPS).

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

### IaaS {#iaas}

**Infrastructure as a Service**: A cloud service model that rents out compute, storage and network resources, such as virtual machines and disks, on demand. The vendor runs the hardware, and the user manages the operating system and everything above it. See [Wikipedia](https://en.wikipedia.org/wiki/Infrastructure_as_a_service).

### 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}

### JIT {#jit}

**Just-in-Time Compilation**: The compilation of a program's code to machine code while the program runs, instead of before. The compiler can use what is known only at run time, such as the actual data, but the compile time adds to the run time, so it pays off mostly on long-running code. PostgreSQL, for example, compiles parts of long, CPU-bound analytical queries, such as their expressions, with LLVM. See [Wikipedia](https://en.wikipedia.org/wiki/Just-in-time_compilation), [PostgreSQL docs](https://www.postgresql.org/docs/current/jit.html).

### 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}

### `lz4` {#lz4}

A lossless compression algorithm and format by Yann Collet from the LZ77 family, built for speed rather than compression ratio. It compresses and especially decompresses much faster than gzip, at a lower ratio; its higher levels use a slower high-compression mode that keeps decompression fast. See [LZ4](https://lz4.org/).

## N {#letter-n}

### `netem` {#netem}

**Network Emulator**: A Linux traffic control queueing discipline that adds delay, jitter, packet loss, duplication or reordering to the packets leaving a network interface. It is used to test how software behaves on slow or unreliable networks. See [SRT cookbook](https://srtlab.github.io/srt-cookbook/how-to-articles/using-netem-to-emulate-networks.html).

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

## O {#letter-o}

### OLTP {#oltp}

**Online Transaction Processing**: A class of workloads made of many short, concurrent transactions that each read or update a few rows, such as orders, payments or bookings. OLTP databases are optimized for the latency and throughput of such transactions, unlike analytical databases built for large scans. See [Wikipedia](https://en.wikipedia.org/wiki/Online_transaction_processing).

### OS {#os}

**operating system**: The software that manages a computer's hardware and runs programs on it, such as Linux or Windows. A cloud server runs the OS of the image it was started from.

## P {#letter-p}

### Parallel Query {#benchmark-pgbench-postgres-parallel-query}

A PostgreSQL feature that splits one query across several worker processes, for example to scan, join or aggregate a large table on several CPU cores at once. The `max_parallel_workers_per_gather` setting limits how many workers one part of a query can use. See [PostgreSQL docs](https://www.postgresql.org/docs/current/parallel-query.html).

### PassMark {#passmark}

The PerformanceTest benchmark suite of PassMark Software, for Windows, Linux, macOS, and mobile devices. It runs fixed CPU, memory, disk, and graphics tests, such as math workloads involving compression, encryption, and physics simulations, and combines the results into an overall PassMark Rating. See [PerformanceTest](https://www.passmark.com/products/performancetest/).

### `pgbench` {#pgbench}

The benchmark tool shipped with PostgreSQL. It runs a SQL script repeatedly over many concurrent client sessions, and reports the throughput in transactions per second and the latency. Its built-in script is modeled on TPC-B, and custom scripts can define any other workload. See [PostgreSQL docs](https://www.postgresql.org/docs/current/pgbench.html).

### `pgtune` {#benchmark-pgbench-postgres-pgtune}

A web tool that suggests PostgreSQL settings, such as `shared_buffers` and `work_mem`, from the memory, CPU count, storage type and workload of a server. Its suggestions are a starting point for tuning rather than an optimum. See [pgtune](https://pgtune.leopard.in.ua/).

### PL/pgSQL {#benchmark-pgbench-postgres-pl-pgsql}

**PostgreSQL Procedural Language**: The built-in procedural language of PostgreSQL, which adds variables, loops, conditionals and error handling to SQL. It is used to write functions, procedures and triggers that run inside the database server. See [PostgreSQL docs](https://www.postgresql.org/docs/current/plpgsql.html).

### PostgreSQL {#postgresql}

An open-source object-relational database system, developed by a global community and descended from the POSTGRES project at UC Berkeley in 1986. It uses and extends SQL, with transactions, many index types, extensions, and JSON data. See [PostgreSQL docs](https://www.postgresql.org/docs/).

## R {#letter-r}

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

### RDBMS {#rdbms}

**Relational Database Management System**: A database system that stores data in tables of rows and columns, related through keys and queried with SQL. It keeps data consistent with constraints and transactions; PostgreSQL, MySQL and Oracle Database are examples. See [Wikipedia](https://en.wikipedia.org/wiki/Relational_database).

### Redis {#redis}

An open-source, in-memory key-value data store, used as a database, cache, and message broker. It keeps its data in RAM, supports data structures such as strings, hashes, lists, and sets, and can persist data to disk with periodic snapshots or an append-only log. See [Redis docs](https://redis.io/docs/latest/).

### RTT {#rtt}

**Round-Trip Time**: The time a network packet takes to reach its destination plus the time its response takes to get back. It sets a lower bound on the latency of every request-response exchange, and grows with the distance between the endpoints. See [Wikipedia](https://en.wikipedia.org/wiki/Round-trip_delay).

## S {#letter-s}

### SQL {#sql}

**Structured Query Language**: The standard language to define, query and modify data in relational databases. Its declarative statements, such as SELECT, INSERT and UPDATE, describe what data to return or change, and the database plans how to do it. See [Wikipedia](https://en.wikipedia.org/wiki/SQL).

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

### SSL {#ssl}

**Secure Sockets Layer**: A protocol that encrypts network connections and verifies the identity of the server, and optionally of the client, with certificates. TLS has replaced it, but SSL is still the common name for both, including in PostgreSQL's settings. See [PostgreSQL docs](https://www.postgresql.org/docs/current/ssl-tcp.html).

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

### `sysbench` {#benchmark-pgbench-postgres-sysbench}

A scriptable, multi-threaded benchmark tool built on LuaJIT. Its tests cover CPU, memory, file I/O, threads, and mutexes, and its Lua scripts run transactional database workloads against MySQL and PostgreSQL. It reports rates and latency percentiles. See [GitHub](https://github.com/akopytov/sysbench).

## T {#letter-t}

### TOAST {#benchmark-pgbench-postgres-toast}

**The Oversized-Attribute Storage Technique**: The mechanism with which PostgreSQL stores values too large for a regular 8 kB page, by compressing them, moving them out of line into a separate table, or both. It applies automatically to large values, such as long texts or JSON documents. See [PostgreSQL docs](https://www.postgresql.org/docs/current/storage-toast.html).

### TPC-B {#tpc-b}

**Transaction Processing Performance Council Benchmark B**: A database benchmark of short, update-heavy banking transactions, each updating an account, a teller and a branch balance and logging the change. The TPC retired it in 1995, but the default script of `pgbench` is still modeled on it. See [TPC](https://www.tpc.org/tpcb/).

### TPM {#benchmark-pgbench-postgres-tpm}

**Transactions Per Minute**: A throughput measure of transaction processing systems: the number of transactions they complete per minute. TPC-C reports a variant of it, tpmC, which counts only new-order transactions, while tools such as `pgbench` report transactions per second (TPS), which is 1/60 of TPM. See [Wikipedia](https://en.wikipedia.org/wiki/Transactions_per_second).

### TPROC-C {#benchmark-pgbench-postgres-tproc-c}

**HammerDB's transaction processing workload**: The OLTP workload of the HammerDB benchmark tool, derived from the TPC-C specification of an order-entry system with warehouses, orders and payments. It is not an official TPC-C implementation, so its results are not comparable with published TPC-C results. See [HammerDB docs](https://www.hammerdb.com/docs/).

## U {#letter-u}

### URL {#url}

**Uniform Resource Locator**: The address of a resource on the web or a network, such as https://sparecores.com/, made of a scheme, a host, and a path.

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

### VPC {#vpc}

**Virtual Private Cloud**: An isolated virtual network within a public cloud account, with its own IP address ranges, subnets, routing and firewall rules. Resources such as virtual machines and databases are placed in it to control how they reach each other and the internet. See [Wikipedia](https://en.wikipedia.org/wiki/Virtual_private_cloud).

## W {#letter-w}

### WAL {#wal}

**Write-Ahead Logging**: A technique in which a database writes each change to a durable log before it changes the data files. After a crash, replaying the log restores a consistent state, and shipping it to other servers drives replication and point-in-time recovery. PostgreSQL, for example, calls its log the WAL, and on write-heavy workloads the speed of WAL writes often limits throughput. See [Wikipedia](https://en.wikipedia.org/wiki/Write-ahead_logging), [PostgreSQL docs](https://www.postgresql.org/docs/current/wal-intro.html).

## Y {#letter-y}

### YCSB {#ycsb}

**Yahoo! Cloud Serving Benchmark**: An open-source benchmark framework, released by Yahoo! in 2010, for key-value and NoSQL databases. It runs standard workloads that mix reads, updates, inserts and scans in different proportions, and is widely used to compare cloud data stores. See [Wikipedia](https://en.wikipedia.org/wiki/YCSB).

## Z {#letter-z}

### Zipfian {#zipfian}

A skewed probability distribution, named after Zipf's law, in which an item's frequency is inversely proportional to its rank, so a few items are accessed far more often than the rest. Benchmarks use it to model real-world hot spots, such as popular products or users. See [Wikipedia](https://en.wikipedia.org/wiki/Zipf%27s_law).
