Memory & Resource Management

Choose who owns the memory

An engine allocates memory for data it processes: leave it to the garbage collector, or take it off-heap as an arena, a typed pool, a dictionary or capped buffers? Four questions, then two checks on placement and peak.

Tune a buffer pool

A database caches disk pages in a buffer pool: isolate scans, use Clock, or pay for 2Q or ARC? Three questions pick the replacement policy; three checks find the pool's usable size and the failures upstream of the policy.

Ration memory across queries

Many queries share one machine's memory: list what cannot spill, check where grants come from, size grants in steps, decide between reservation and over-commit, and keep the pressure loop from oscillating.

Plan for running out of memory

When a query outgrows its memory, it spills to disk or is killed: list what cannot spill, compute what spilling really costs on your hardware, guard against one oversized key, and make sure a killed query retries with more memory.

Arena versus `malloc`: the 50× claim

100 million 24-byte objects with malloc/free and with a bump arena; then fragmentation: resident memory against live bytes.

GC cost against headroom: `1 / (H/L − 1)`

A Java program with a live set of small objects at heap sizes from 1.25 to 7 times the live set: GC share of time against 1/(H/L − 1); then the live set off-heap.

Find your NUMA effect (first touch) and measure it honestly

Scan a 1 GB array with all cores after single-threaded, parallel and interleaved first touch, in a Linux container: a single-node control run.

LRU, random and Clock on a cyclic loop

LRU, random and Clock replaying a loop over 100 pages for pools of 1 to 100 frames; then a one-time scan against a hot set under LRU, 2Q and a scan ring.

Scan resistance in a real database (PostgreSQL)

PostgreSQL with a 128 MB buffer pool: a hot table's pages after a sequential scan of a 1 GB table, and after reading the same table through an index.

Grant quantization: count the passes

The external sort pass count ⌈log_(M/B − 1)(N/M)⌉ for 1 TB across memory grants; then PostgreSQL sorting 5 million rows from work_mem 64 kB to 1 GB.

The spill cliff: 5% spilled, how much slower?

Measure memory and disk bandwidth, then spill 0%, 5% and 20% of an 800 MB array to a file and back: the slowdown against (1 − f) + 2·f·r.

Sort versus hash under a hot key

50 million rows with 30% on one key under a 500 MB DuckDB limit: SUM/COUNT against median by key, and a grace partitioner's largest partition under 5 hash seeds.

Queueing on the spill device

Rate-limited sequential writers sharing one SSD at 20% to 100% of its measured throughput: completion latency against S/(1 − ρ).

Interview questions

Short questions on how data systems manage memory, such as ownership and allocation, buffer pools and replacement policies, memory grants and spilling, each with an answer you could give aloud and a link to the full explanation.

Scenarios

Longer problems on memory management in data systems, of the kind asked in senior interviews: each one estimated with numbers, diagnosed, and answered with its trade-offs.