Wear leveling and flash controllers: Visual walkthrough

Step 1 — Draw the thing we are counting: a block of pages

WHAT. A flash block is a fixed grid of small boxes called pages. Let the letter $N$ just mean "how many pages are in one block" — a plain count, like 64. Nothing mysterious: $N$ is the number of little squares in our picture.

WHY start here. Every write, every erase, every copy in this whole story is measured in pages. If we don't fix a unit to count in, "write amplification" is just a vibe. The block is our ruler.

PICTURE. Below, one block drawn as a strip of squares. Each square is one page. We will colour these squares in later steps; right now they're all blank — a brand-new, freshly-erased block.

Figure — Wear leveling and flash controllers

Step 2 — Why data goes stale: writing never overwrites

WHAT. When the host rewrites some data, flash cannot change the old square in place. The controller writes the new version into a fresh square and marks the old one as garbage. We'll paint garbage squares pink and call them stale. Live, still-wanted squares we paint blue and call valid.

WHY. This is the erase-before-write rule from the parent. Because old copies can't be scrubbed one-at-a-time, they pile up as pink squares scattered through the block. The block slowly fills with a mix of blue (needed) and pink (dead-weight).

PICTURE. The same block, now partly used: some squares blue (valid), some pink (stale). Notice the pink squares are wasted space we can't reuse until we erase the entire block.

Step 3 — Name the mix with one number: the valid fraction $u$

WHAT. Instead of tracking exactly which squares are blue, we track just their proportion. Let

$u = a fraction between 0 and 1 \frac{number of blue (valid) pages}{total pages in the block}$

The top counts blue squares only.
The bottom is $N$ , the whole strip.
So $u$ is a slider from $0$ (no blue at all) to $1$ (every square blue).

WHY this tool and not raw counts? Because the final answer won't depend on how big the block is — only on how full of live data it is. A number between 0 and 1 is exactly the right handle: it lets one formula cover a 64-page block and a 512-page block identically.

PICTURE. The block with a slider underneath: drag left → mostly pink (small $u$ ), drag right → mostly blue (large $u$ ). The blue-shaded bar shows the size of $u$ .

Step 4 — Split the block into "must copy" and "was wasted"

WHAT. Take our $N$ -page block. The blue part is $u \times N$ pages. The pink part is everything else, $(1 - u) \times N$ pages.

blue: valid pages u N + pink: stale pages (1 - u) N = N

$u N$ — the squares we are forced to rescue (copy elsewhere) before we can erase.
$(1 - u) N$ — the squares that were pure garbage; erasing them costs us nothing but gives back real free space.

WHY split like this? Because these two piles have completely different jobs. One pile is work we do for free space we don't even keep (the copies). The other pile is the actual free space we win. Amplification is the ratio between them — so we must separate them first.

PICTURE. The block sliced into a blue segment of length $u N$ and a pink segment of length $(1 - u) N$ , each labelled.

Step 5 — Watch garbage collection actually run

WHAT. Garbage Collection cleans this block in three moves:

Copy the $u N$ blue pages into a fresh block (that's $u N$ real writes to flash).
Erase the strip — all $N$ squares become blank again.
Now the strip has $N$ blank pages, but $u N$ of them are already spoken for by the copies we just made.

So after one cleanup, the genuinely-new free space we can hand back to the host is:

free pages won = N - u N = (1 - u) N

WHY. This is the accounting heart of the whole page. The host thinks it got $(1 - u) N$ fresh pages. But to hand those over, the drive secretly also did $u N$ copy-writes. The host never asked for those copies — they're pure overhead.

PICTURE. Three panels left-to-right: (a) dirty block, (b) blue pages flying out to a fresh block via arrows (the copies), (c) the erased block, now blank, with the fresh block holding the rescued blue pages.

Step 6 — Total the writes and form the ratio

WHAT. Add up every write that hit the flash during that cleanup cycle, then divide by the writes the host actually asked for.

WAF = \frac{all physical writes}{writes the host wanted} = \frac{( 1 - u ) N host’s real data + u N copies}{host’s real data ( 1 - u ) N}

Numerator = host's own data $(1 - u) N$ plus the rescued copies $u N$ . Together they sum to $N$ .
Denominator = only the host's data $(1 - u) N$ — the useful part.

Simplify the numerator: $(1 - u) N + u N = N$ . So

WAF = \frac{N}{( 1 - u ) N} = \frac{1}{1 - u}

WHY divide? "Amplification" means a ratio: how many bytes truly hit the flash per byte the host requested. Division is the only operation that answers "how many times bigger?". The $N$ cancels top and bottom — proving the block size never mattered, only $u$ does.

PICTURE. A fraction drawn as two stacked bars: the top bar (length $N$ ) split blue+pink; the bottom bar (length $(1 - u) N$ ) just the pink-derived useful part. The eye sees WAF as "how much taller the top bar is."

Step 7 — The edge cases (never skip these)

WHAT & WHY. A formula you can't reason about at its extremes is a formula you don't understand. We test all three corners of the $u$ -slider.

$u = 0$ (all pink, no blue). $WAF = \frac{1}{1 - 0} = 1$ . Picture: an all-pink block. Nothing to rescue → erase gives $N$ free pages for zero copies. This is the dream and the hard floor of the GC formula: you can never do better than 1 by cleaning.
$u \to 1$ (almost all blue). $WAF = \frac{1}{1 - u} \to \infty$ . Picture: an all-blue block. To free even one page you copy nearly the whole block. This is the disaster GC tries to avoid — it explains why the drive picks the emptiest victim block, and why Over-provisioning and TRIM (extra spare space) keeps $u$ low.
$u = 1$ exactly (fully valid). Division by $(1 - 1) = 0$ is undefined — and rightly so: a fully-valid block has no free space to gain, so cleaning it is meaningless. The math refuses because the action is pointless.

PICTURE. Three tiny blocks side by side (all-pink, half, all-blue) with their WAF values $1$ , $2$ , $\infty$ printed under them, and the curve $\frac{1}{1 - u}$ swooping up on the right.

The one-picture summary

Everything collapses into one image: the $u$ -slider on the bottom, the block above it changing colour, and the WAF-curve $\frac{1}{1 - u}$ climbing from $1$ at the left to a wall at $u = 1$ . Slide right (blocks fuller) → curve rockets up → drive dies faster. Add spare space → slide left → curve calms down → drive lives longer.

Recall Feynman retelling — say it like a story

Picture a strip of little boxes: that's a flash block. Some boxes still hold data you need (paint them blue), some hold junk you already replaced (paint them pink) — because flash can't erase junk one box at a time. To recycle the strip you must burn the whole thing, so first you rescue every blue box by copying it somewhere fresh. Those copies are extra writes nobody asked for. Call $u$ the share of blue boxes. Out of the whole strip $N$ , the copies cost you $u N$ writes, and the truly-new space you win back is only $(1 - u) N$ . Divide total writes by the useful writes and the strip-size $N$ cancels, leaving $\frac{1}{1 - u}$ . If the strip was all junk ( $u = 0$ ) you copy nothing — amplification is 1, perfect. If the strip was nearly all blue ( $u \to 1$ ) you copy almost everything to free almost nothing — amplification blows up to infinity. That single curve is why keeping empty space (over-provisioning) is the secret to a long-lived SSD.

Recall Quick self-test

If GC picks blocks that are 50% valid, what is WAF? ::: $\frac{1}{1 - 0.5} = 2$ As $u \to 0$ , WAF approaches what? ::: $1$ (the ideal floor) Why does block size $N$ not appear in the final formula? ::: It cancels top and bottom in Step 6. What real mechanism lets you keep $u$ small? ::: Over-provisioning and TRIM — extra spare space lets GC wait for emptier victims.