The four questions, and the shift from efficiency to arbitration

Why is memory management finally judged on isolation versus utilization?

The mechanisms here are not independent topics. They fall into four questions. The order is also the order in which each presupposes the previous one.

Part	Question	Mechanisms	What the application knows that the layer below does not
Ownership	Who allocates, who frees, where do the bytes physically sit?	arenas/regions, off-heap, GC tuning vs. manual management, Arrow-style pooling, string interning / dictionary reuse, NUMA placement	lifetime and shape of data in advance
Residency	Of the data that does not fit, which part is in memory right now?	buffer-pool replacement (LRU, LRU-K, Clock, 2Q, ARC), pinning and unpinning	the future reference pattern, and the fact that this access is a scan
Rationing	Who gets how much, decided when?	memory grants and reservations, admission control by footprint, pressure signalling and operator cooperation	an estimate of the footprint before execution
Degradation	What happens at the boundary?	spill-to-disk for hashes, sorts, joins	which state can be rebuilt and at what cost

Ownership and Residency are about one consumer being efficient. Rationing and Degradation are about many consumers sharing. That shift, from efficiency to arbitration, is the real spine of this mechanism. It also explains why the isolation versus utilization trade-off is the one on which this mechanism is finally judged:

Reservations buy isolation at the cost of utilization; over-commit buys utilization at the cost of correlated failure (the core tension of rationing).

Case, resolvedConstructed case · Amara at Voltara

OOM-killed at 3:10, or seven hours with swap

The nightly billing job on a 256 GB server with a 200 GB heap was killed by the OOM killer at 3:10 am, and turning swap on made it run seven hours instead of ninety minutes while the dashboard became unusable. Where it started: Memory is a space resource →

Amara now draws a picture on the whiteboard. RAM has several claimants: the engine's own cached pages, the working memory of every running query, the OS page cache, and the runtime's overhead. The 200 GB heap left too little for the other claimants, and the page cache that free showed was not "waste": it competed with the heap for the same bytes. The 3:10 am kill happened because nobody had decided in advance who may hold how much.

Swap did not fix this. Swap chose pages by recency, and the job's hash tables look cold between probes, so the kernel threw out exactly the pages the join was about to read. The "fix" turned a clean failure into a seven-hour crawl.

Her plan for the quarter has four steps: take memory decisions inside the engine (Ownership and Residency), ration memory before work starts (Rationing), and define what happens when the ration is not enough (Degradation).