Reference

Relationships

An index of the arithmetic the mechanisms use. Each relationship is stated once, in general symbols, with a chart of how it behaves, and links to every page that uses it under its own names.

What is here

Laws (28) — Hold everywhere: identities and limits that need no assumptions about the workload.
Models (110) — Hold under stated assumptions; each says which.
Definitions (55) — Named quantities the laws and models are written in.

How a page reads

The general form, typeset, with what each symbol stands for.
How it behaves — a chart of the output as one input changes and the others stay fixed.
Worked examples, recomputed: every number the mechanisms state is checked against the formula, so none of them disagrees with it.
Where it appears — each mechanism that uses it, in its own names, linked to the page.

Index

A degree of longitude shrinks with latitude
$1^{\circ} of longitude \approx 111 km \times cos (latitude)$
law
Alert precision is a base-rate problem
$precision = \frac{r \cdot recall}{r \cdot recall + ( 1 - r ) \cdot FPR}$
law
Amdahl's Law
$Speedup (N) = \frac{1}{s + \frac{1 - s}{N}} \leq \frac{1}{s}$
law3 mechanisms
Arrhenius retention
$t_{retention} \propto e^{E_{b} / k T}$
law
Availability is dominated by repair time
$A = \frac{MTBF}{MTBF + MTTR}, 1 - A \approx \frac{MTTR}{MTBF}$
law
Deadline feasibility (EDF)
$\sum_{i} \frac{C _{i}}{T _{i}} \leq 1$
law
Dependent calls pay every round trip
$t \geq dependent calls \times RTT$
law3 mechanisms
Digest collisions (the birthday bound)
$P (collision) \approx 1 - exp (- \frac{n ^{2}}{2 ^{b + 1}})$
law
Entropy: the floor for any code
$H = - \sum_{i} p_{i} lo g_{2} p_{i} bits per value$
law
Error falls as one over the square root
$error \approx \frac{c}{m}$
law5 mechanisms
Gustafson's Law
$Speedup (N) = N - s (N - 1)$
law
Join output size
$∣ R ⋈ S ∣ = \sum_{v} f_{R} (v) \cdot f_{S} (v)$
law2 mechanisms
Little's Law
$L = λW$
law18 mechanisms
MinHash estimates Jaccard similarity
$P (min_{A} h = min_{B} h) = \frac{∣ A \cap B ∣}{∣ A \cup B ∣} = J (A, B)$
law
Order changes flow time, not throughput
$busy time is the same for every work-conserving order, \overset{ˉ}{F} = \frac{1}{n} \sum_{i} C_{i} is smallest shortest-first$
law
Pairwise coordination against a shared hub
$pairwise: \frac{N ( N - 1 )}{2} (or N \times M), through a shared vocabulary: N (or N + M)$
law5 mechanisms
Percentiles do not average
$p_{q} (A \cup B) \neq = \frac{p _{q} ( A ) + p _{q} ( B )}{2}$
law3 mechanisms
Quorum intersection
$R + W > N ⟹ every read set meets every write set$
law3 mechanisms
Ratios do not average
$\frac{1}{n} \sum_{i} \frac{a _{i}}{b _{i}} \neq = \frac{\sum _{i} a _{i}}{\sum _{i} b _{i}}$
law2 mechanisms
Shared fate caps availability
$A_{system} \leq A_{shared}, P (joint failure) \geq q whatever p^{R}$
law
The ceiling on a result cache
$h \leq P (a byte-identical query recurs within the inter-write interval of its inputs)$
law
The delta rule for a join
$Δ (R ⋈ S) = Δ R ⋈ S \cup R ⋈ Δ S \cup Δ R ⋈ Δ S$
law
The latency floor of consistency
$r + w \geq d (sequential consistency), r \geq \frac{u}{4}, w \geq \frac{u}{2} (linearizability)$
law
The power of two choices
$max load - mean : Θ (\frac{l n n}{l n l n n}) (one random choice) \to Θ (ln ln n) (best of two)$
law2 mechanisms
What a fault costs
$cost = damage rate \times (t_{detect} + t_{decide} + t_{repair})$
law
What you are billed
$billed = ⌈ \frac{q}{g} ⌉ \times g \times r$
law
Why 2f + 1
$Q \leq N - f, 2 Q > N ⟹ N \geq 2 f + 1, Byzantine: N \geq 3 f + 1$
law
Work and span bound parallel time
$T_{p} \geq max (\frac{T _{1}}{p}, T_{\infty})$
law
A delayed controller oscillates
$period \approx 2 d$
model2 mechanisms
Admitting traffic to a cold cache
$(1 - h (t)) λ (t) < origin capacity ⟺ λ (t) < \frac{capacity}{1 - h ( t )}$
model
Asserted metadata decays
$P (still correct after t years) = (1 - c)^{t}$
model
Automatic or manual failover
$P (real failure) \times downtime saved > P (false alarm) \times cost of a spurious failover$
model
Balls in bins: the fullest partition
$max_{i} n_{i} - \frac{M}{N} \approx 2 \frac{M}{N} ln N$
model
Block nested loop I/O
$I/O = ∣ R ∣ + ⌈ \frac{∣ R ∣}{M} ⌉ ∣ S ∣$
model
Bloom filter false positives
$FPR = (1 - e^{- kn / m})^{k}, k^{*} = \frac{m}{n} ln 2, FPR^{*} = e^{- \frac{m}{n} l n^{2} 2}$
model
Broadcast or shuffle a join
$broadcast: ∣ S ∣ P shuffle: ∣ R ∣ + ∣ S ∣ broadcast wins when \frac{∣ R ∣}{∣ S ∣} ≳ P$
model
Brute-force vector search is memory-bound
$bytes = N \times d \times 4, t_{query} \approx \frac{N d \cdot 4}{memory bandwidth}, I \approx 0.5 FLOP/byte$
model
Buffer survival under overload
$t_{survive} = \frac{C}{λ - μ}, Q (t) = (λ - μ) t$
model3 mechanisms
Cache leverage
$load on the backing store = (1 - h) λ, leverage = \frac{1}{1 - h}$
model2 mechanisms
Catching up after an outage
$t_{recover} = \frac{backlog}{replay throughput - arrival rate}, recover in \frac{T}{k} ⟺ M = (k + 1) a$
model4 mechanisms
Cells: smaller, more frequent outages
$E [user-minutes lost] = k \cdot outage \cdot \frac{1}{k} = unchanged$
model
Commit wait under bounded clock uncertainty
$t_{wait} \approx ε to 2 ε$
model
Compaction debt
$λ_{m a x} = \frac{disk bandwidth}{write amplification}, write amplification \approx T \cdot L$
model
Compression on the wire
$T_{plain} = \frac{S}{B}, T_{comp} = \frac{S}{c} + \frac{S}{r B} + \frac{S}{d}$
model
Conflict grows with the square of throughput
$conflicts \approx \frac{L ^{2} k ^{2}}{2 N}, L = λW$
model
Copysets: frequency against blast radius
$P (loss ∣ 3 nodes fail) \approx \frac{distinct replica triples used}{( 3 N )}$
model
Count-min sketch guarantee
$\hat{f} \leq f + εN with probability 1 - δ, w = ⌈ e / ε ⌉, d = ⌈ ln (1/ δ)⌉$
model
Cyclic access: LRU against random replacement
$h_{LRU} = {01 c < n c \geq n, h_{random} = (1 - \frac{1}{c})^{n (1 - h)} \approx e^{- n (1 - h) / c}$
model
Deduplication window
$W > maximum duplicate delay, keys held = rate \times W$
model
Delay scheduling for locality
$wait ⟺ E [wait] < (1 - \frac{1}{ratio}) \times runtime, E [wait] \approx \frac{T}{k}$
model
Dictionary encoding: when it pays
$size = N ⌈ lo g_{2} k ⌉ bits + k \times \overset{s}{ˉ}$
model
Differential-privacy noise and budget
$noise \approx \frac{sensitivity}{ε}, ε_{total} = \sum_{i} ε_{i}$
model
Effective price
$effective price = \frac{list rate}{utilization ( 1 - granularity waste )}$
model
Elastic or provisioned
$elastic wins ⟺ d \times k < 1, cold start bills \frac{t _{warm} + t _{job}}{t _{job}}$
model
Elias–Fano: space of a sorted sequence
$bits = n (2 + ⌈ lo g_{2} \frac{u}{n} ⌉)$
model
Exponential backoff with full jitter
$sleep_{n} \sim U (0, min (cap, base \cdot 2^{n}))$
model2 mechanisms
External sort: passes and fan-in
$passes = 1 + ⌈ lo g_{F} \frac{N}{M} ⌉, I/O = 2 N \times passes, F \leq \frac{M}{efficient read size}$
model3 mechanisms
Fanout and tree depth
$f = \frac{page size}{key size + pointer size}, depth = lo g_{f} N$
model2 mechanisms
Finding the rows that differ
$bytes exchanged \approx d \cdot lo g_{2} n \cdot h$
model
Fixed cost per operation
$T (x) = F + \frac{x}{B}, x_{1/2} = F \cdot B$
model8 mechanisms
Garbage-collection overhead and headroom
$overhead \propto \frac{1}{H / L - 1} = \frac{L}{H - L}$
model2 mechanisms
Graph traversal is exponential in depth
$frontier at hop k \approx d^{k}, bidirectional: 2 d^{k /2}$
model2 mechanisms
Hedged requests
$P (slow) = p^{k} (k independent attempts), extra load \approx the hedged fraction$
model2 mechanisms
How a type 2 dimension grows
$new rows per year = members \times changes per member per year$
model
How wide a block's min–max range is
$E [max - min] = \frac{b - 1}{b + 1} (random order), \approx \frac{1}{blocks} (sorted)$
model2 mechanisms
How wide a shuffle can be
$b = \frac{S}{MR}, M = R \leq \frac{S}{b _{m i n}}$
model
Hybrid hash: a ramp, not a cliff
$spilled fraction = \frac{m - M}{m} (m > M)$
model
Incremental or full recompute
$S c = Δ S c^{'} + F ⟹ incremental wins when Δ < (1 - \frac{F}{S c}) \cdot \frac{c}{c ^{'}}$
model
Jitter spreads a herd
$peak \approx \frac{N}{ε} \to \frac{N}{W}$
model
Join size estimate
$∣ A ⋈ B ∣ \approx \frac{∣ A ∣ \times ∣ B ∣}{m a x ( V ( A , a ) , V ( B , b ) )}$
model
Keys moved by a membership change
$moved_{ring} \approx \frac{K}{N}, moved_{mod N} \approx K \frac{N - 1}{N}$
model2 mechanisms
Kingman's approximation
$W_{q} \approx \frac{ρ}{1 - ρ} \cdot \frac{c _{a}^{2} + c _{s}^{2}}{2} \cdot S$
model
Linear probing: probes by load factor
$hit \approx \frac{1}{2} (1 + \frac{1}{1 - α}), miss or insert \approx \frac{1}{2} (1 + \frac{1}{( 1 - α ) ^{2}})$
model
Loop gain
$total work = 1 + R + R^{2} + \dots = \frac{1}{1 - R} (R < 1), unbounded for R \geq 1$
model
Losing every replica
$P (all n lost) = p^{n} (independent) vs \approx p_{common} (one common cause)$
model
LSH banding: the S-curve
$P (candidate) = 1 - (1 - J^{r})^{b}, threshold \approx (\frac{1}{b})^{1/ r}$
model
LSM compaction: leveled against tiered
$L = lo g_{T} \frac{N}{M}; leveled: W \approx T L, R \approx L, S \approx 1 + \frac{1}{T}; tiered: W \approx L, R \approx T L, S \approx T$
model2 mechanisms
Merge-on-read against copy-on-write
$MoR wins when w \cdot U > r \cdot c \cdot \overset{ˉ}{k}, \overset{ˉ}{k} \approx \frac{w τ}{2}$
model
Naive retry on one pointer
$T_{all} \approx \frac{n ^{2} T}{2}$
model
Nulls: bitmap or positions
$N (bitmap) vs m lo g_{2} N (positions), equal at \frac{m}{N} = \frac{1}{l o g _{2} N}$
model
Optimistic against pessimistic
$k \cdot c_{lock} (locking, every time) vs p_{conflict} \cdot work (optimistic, on conflict)$
model
Order predicates by rows removed per unit of cost
$evaluate i before j ⟺ \frac{1 - s _{i}}{c _{i}} > \frac{1 - s _{j}}{c _{j}}$
model
Pages a range query reads
$clustered \approx \frac{k}{f} (sequential), unclustered \approx min (k, \frac{N}{f}) (random)$
model
Patched frame of reference
$bits = N \times w + e \times (w_{full} + w_{pos})$
model
Pattern matching state explodes
$partial matches per key \leq 2^{k} (A B* C, relaxed matching)$
model
Query cost across index segments
$query cost \approx segments \times terms \times dictionary lookup + postings work$
model
Recovery time from the checkpoint interval
$t_{recovery} \approx τ \cdot \frac{write rate}{replay rate}$
model
Request charges per gigabyte
$\frac{$}{GB} = \frac{price per million requests}{1 0 ^{6} \times object size (GB)}$
model
Restart interval of front coding
$cost (r) = α lo g_{2} \frac{N}{r} + \frac{r}{2}, r^{*} = \frac{2 α}{l n 2}$
model
Restarting the whole query
$P (no task fails) \approx e^{- n T λ}, E [attempts] \approx e^{n T λ}$
model
Retry amplification across layers
$A = a^{L}, T_{outer} > a \cdot T_{inner}$
model4 mechanisms
Retrying tasks, not jobs
$P (job succeeds) = (1 - p)^{n} \approx e^{- n p} \to (1 - p^{k})^{n} with k attempts per task$
model
Role explosion
$roles needed \approx 2^{d} (d independent yes/no dimensions), or \prod_{i} n_{i}$
model
Rows a sample needs to see a rare defect
$n \approx \frac{- l n β}{p}$
model
Run-length encoding and row order
$runs_{random} \approx N (1 - \frac{1}{k}), runs_{sorted} = k, ratio_{sorted} = \frac{N}{k}$
model
Scan time with per-file overhead
$t_{scan} \approx \frac{NF}{P} + \frac{D}{B}$
model
Scrubbing: bandwidth and the detection window
$scrub bandwidth = \frac{stored bytes}{cycle}, cycle + alert lag < retention$
model
Selectivity under independence
$sel (a \land b) = sel (a) \times sel (b)$
model2 mechanisms
Share a subexpression or recompute it
$share when c_{compute} \times (k - 1) > c_{materialize} + \sum_{i = 1}^{k} c_{adapt, i}$
model
Shuffle sharding
$P (a tenant shares my exact shard) = \frac{1}{( k n )}$
model
Slow-start ramp
$t \approx RTT \cdot lo g_{2} \frac{W}{W _{0}}$
model
Space of an approximate membership filter
$floor = lo g_{2} \frac{1}{ε}, Bloom = \frac{1}{l n 2} lo g_{2} \frac{1}{ε} \approx 1.44 lo g_{2} \frac{1}{ε}, cuckoo \approx \frac{l o g _{2} ( 1/ ε ) + 3}{α}$
model
Statistical multiplexing
$separate: n (μ + z σ) shared: n μ + z n σ$
model
Synchronous commit latency
$t_{sync} \approx t_{flush} + RTT + t_{flush, replica}$
model
Tail at scale
$P (slow) = 1 - (1 - p)^{N}$
model4 mechanisms
The barrier waits for the maximum
$\frac{E [ m a x ]}{E [ mean ]} \approx 1 + c 2 ln n$
model
The composite-key rule
$\frac{N}{C _{a}} \geq G ⟺ C_{a} \leq U$
model
The five-minute rule
$break-even interval = \frac{pages per MB of RAM \times price of one access per second}{price of one MB of RAM}$
model
The metastable band
$\frac{C}{k} < λ < C ⟺ \frac{1}{k} < ρ < 1$
model
The misses own the mean
$\overset{ˉ}{t} = h t_{hit} + (1 - h) t_{miss}, equal shares at h = \frac{t _{miss}}{t _{miss} + t _{hit}}$
model
The queueing wall (M/M/1)
$R = \frac{S}{1 - ρ}$
model
The roofline model
$P = min (π, I \cdot β)$
model
The square-root rule
$C (x) = a x + \frac{b}{x}, x^{*} = \frac{b}{a}, C (x^{*}) = 2 ab$
model6 mechanisms
The watermark
$watermark = max (event time seen) - δ, global watermark = min_{partitions} watermark_{p}$
model
The Z-order floor
$L = U^{- 1/ d}, units touched \geq U^{1 - 1/ d}$
model
Unanimity multiplies unavailability
$A_{all} = A^{n}, downtime \approx n (1 - A)$
model4 mechanisms
Universal Scalability Law
$C (N) = \frac{N}{1 + α ( N - 1 ) + βN ( N - 1 )}, N^{*} = \frac{1 - α}{β}$
model2 mechanisms
What a commitment really saves
$saving = \frac{\sum _{t} ( list _{t} - committed price )}{\sum _{t} list _{t}}, commit at the demand quantile equal to the discount$
model
What a defect costs
$defect cost \approx detection latency \times downstream fan-out \times consequence per consumer$
model
What a majority quorum buys
$A_{majority} = \sum_{i \geq ⌈(N + 1) /2 ⌉} (i N) p^{i} (1 - p)^{N - i}$
model
What a structural change touches
$cost of a change \propto readers \times age of the data$
model
What clustering can pay
$\frac{units read, random}{units read, clustered} \approx \frac{U m i n ( 1 , s G )}{m a x ( 1 , s U )} \approx min (G, \frac{1}{s})$
model
What columnar storage buys a scan
$reduction = \frac{n}{k} \times c, point read in a column store: \frac{B}{w} amplification, n I/Os$
model
What keeping versions costs in hit rate
$Δ h = \frac{l n V}{l n N}$
model
What partial aggregation saves
$reduction \approx \frac{N}{P G} (a bound), groups seen per partition \approx G (1 - e^{- N / (PG)})$
model
What retained snapshots cost
$storage \approx size \times (1 + f R)$
model2 mechanisms
What spilling costs
$time \propto \frac{( 1 - f ) + 2 f r}{B _{mem}}, r = \frac{B _{mem}}{B _{disk}}$
model
What variance costs in money
$price \div mean demand \approx \frac{peak / mean}{ρ _{target}}$
model
When a cache entry pays
$R = \frac{λ}{w _{eff}} > \frac{P}{S}, w_{eff} = \sum_{i} w_{i}$
model
When an index beats a scan
$k \cdot r < N \cdot s ⟺ \frac{k}{N} < \frac{s}{r}$
model3 mechanisms
When cold storage pays
$p (read) \times retrieval cost < stock saving over the horizon$
model2 mechanisms
When compression speeds up a read
$\frac{S}{r B} + \frac{S}{D} < \frac{S}{B} ⟺ \frac{D}{B} > \frac{r}{r - 1}$
model2 mechanisms
When prefetching pays
$Value = P (hit) \cdot S - C_{fetch} - C_{evict} > 0 ⟺ P (hit) > \frac{C _{fetch} + C _{evict}}{S}$
model
When scaling out mid-query pays
$saved = W (\frac{1}{p} - \frac{1}{p ^{'}}) must exceed S_{startup}, workers \leq \frac{total work}{10 \times min task}$
model
Why removing names does not remove identity
$combinations \approx c^{d} = \prod_{i} c_{i}, almost every record is unique once \prod_{i} c_{i} ≫ N$
model
Write amplification of garbage collection
$WAF = \frac{1}{1 - v}$
model2 mechanisms
Zipf caps data-parallel speedup
$top key share = \frac{1}{H _{K}}, speedup \leq H_{K} \approx ln K + 0.58$
model
Zipf: what the hottest items carry
$h (k) \approx \frac{l n k}{l n N} (α \approx 1), k = N^{h}$
model
Alert fatigue is arithmetic
$E [false alarms] = assertions \times α, P (\geq 1) = 1 - (1 - α)^{n}$
definition
Amplification
$amplification = \frac{bytes touched}{bytes needed}$
definition
Break-even reuse count
$n^{*} = \frac{C _{fixed}}{Δ c}$
definition4 mechanisms
Cost per unit of work
$\frac{$}{job} = \frac{$}{hour} \times \frac{hours}{job}$
definition
Cost-aware eviction: value density
$value density = \frac{expected future hits \times miss cost}{size} (GDSF: f \cdot c / s)$
definition
Costs of a hash shuffle
$files = M \times R, buffer memory = cores \times R \times buffer size$
definition
Dictionary code width
$bits per value = ⌈ lo g_{2} k ⌉$
definition
Endurance budget
$usable writes = \frac{rated cycles}{WAF}$
definition
Erasure coding: overhead and repair
$overhead = \frac{n}{k} = \frac{k + m}{k}, repair read = k \times lost$
definition
Error-budget burn rate
$budget spent before firing = \frac{k \times window}{period}, budget gone in \frac{period}{k}$
definition
Event-time skew
$skew = processing time - event time$
definition
Forces per commit
$commit cost = k \times (cost of one force)$
definition
Freshness and ETA
$freshness = now - max (event time in the dataset), ETA = \frac{remaining work}{observed rate}$
definition
Freshness lag
$freshness lag = t_{captured} - t_{source}$
definition
Headroom a reactive autoscaler needs
$required headroom = ramp rate \times loop delay$
definition
How big keyed state gets
$state = distinct keys \times bytes per key$
definition
How long a backfill takes
$backfill duration = \frac{intervals \times runtime per interval}{runs allowed at once}$
definition
How many files a pipeline writes
$file count = tasks \times partitions \times commits$
definition2 mechanisms
How many runs an experiment needs
$OVAT: 1 + k (L - 1), full factorial: L^{k}, fractional: 2^{k - p}$
definition
How many time series a metric makes
$series = \prod_{labels} distinct values$
definition2 mechanisms
Junk dimension size
$rows \leq 2^{K} (observed combinations are far fewer)$
definition
Key groups
$hash(key) mod max_parallelism \to key group \to instance$
definition
Lease drift margin
$margin = lease \times worst-case drift$
definition
Load per node under replication
$bytes per node = \frac{D R}{N}, work per node = \frac{R w + r}{N}$
definition
Memory grant
$grant = rows \times row width$
definition
Memory held by batching
$memory = B \times record size \times batches in flight$
definition
Moving data through a rate limit
$time = \frac{records}{records per call \times calls per second}$
definition
Off-CPU time
$off-CPU time = wall-clock time - CPU time$
definition
One commit per catalog round trip
$max commits per second = \frac{1}{catalog round trip}, rows per commit \geq \frac{row rate}{max commits per second}$
definition
Periodic snapshot size
$rows = entities \times periods$
definition
Population stability index
$PSI = \sum_{buckets} (a - e) ln \frac{a}{e}$
definition
Reciprocal rank fusion
$score(doc) = \sum_{i} \frac{1}{k + rank _{i}}$
definition
Recovering a streaming job
$t_{recovery} \approx \frac{state}{bandwidth} + catch-up, catch-up = \frac{arrival \times outage}{replay - arrival}$
definition
Retention tiers by resolution
$points per series = \frac{retention}{resolution}$
definition
Roaring container break-even
$16 k = 65, 536 ⟹ k^{*} = 4, 096$
definition
Routing between two price models
$a_{1} + b_{1} x = a_{2} + b_{2} x ⟹ x^{*} = \frac{a _{1} - a _{2}}{b _{2} - b _{1}}$
definition
Serverless cost is memory × time
$cost \propto memory \times duration$
definition
Sliding windows multiply work
$windows per record = \frac{S}{s}$
definition
Sparse index granule
$granule \geq \frac{n \times entry size}{memory budget}$
definition
The expiry invariant
$dedup TTL \geq replay/retry horizon \geq allowed lateness \geq δ$
definition
The miss-ratio curve
$MRC (C) = P (reuse distance \geq C)$
definition
The partition of RAM
$R \geq B + c g + P + O$
definition
The real price of spot capacity
$E [cost] = discounted rate + p (interrupt) \times work lost + engineering cost of handling interruptions$
definition
The value of not reading
$value = (1 - selectivity) \times bytes \times rate \times query frequency$
definition
Transactional sink timeout
$sink transaction timeout > checkpoint interval + detection + restart + backlog drain$
definition
Usable buffer-pool frames
$usable = total - pinned - dirty awaiting log flush$
definition
Utilization
$ρ = λ \cdot S$
definition2 mechanisms
Varint length
$bytes = ⌈ \frac{significant bits}{7} ⌉$
definition
Vector batch size
$N \approx \frac{L1 cache}{k \times value width}$
definition
What an instrument costs
$overhead = call rate \times probe cost$
definition
What keeping an old interface costs
$cost = dual-running duration \times number of callers$
definition
What polling costs
$polls = \frac{waiting time}{poll interval}, E [detection latency] \approx \frac{poll interval}{2}$
definition
When statistics refresh
$rows changed > 0.1 n + 50 (PostgreSQL auto-analyze)$
definition
When to rewrite away deletes
$d \times expected future reads > 1$
definition
Write-back coalescing
$writes collapsed per flush = w \cdot T_{flush}$
definition