RAID — levels 0, 1, 5, 6, 10 — trade-offs: Exercises

Before we start, one reminder of the notation we will reuse, so no symbol is unexplained:

Definition Symbols used on this page

$n$ ::: the total number of physical disks in the array.
$D_{i}$ ::: the $i$ -th data block in a stripe (a chunk of your file's bytes living on disk $i$ ).
$P$ ::: the parity block — a computed check value, not your data.
$Q$ ::: the second parity block (RAID 6 only), computed a different way so it gives new information.
$\oplus$ ::: XOR — bit-by-bit "are these two bits different?". Its one magic law: $x \oplus x = 0$ and $x \oplus 0 = x$ .
I/O ::: one read or one write of a block to a physical disk.
redundancy ::: extra stored information (a copy or a parity block) beyond the single copy of your data, so a lost disk can be rebuilt. RAID 0 stores exactly one copy of each block but no redundancy — copy count and redundancy are different ideas.
RAID 0+1 ::: the reverse-order cousin of RAID 10 — you stripe first (RAID 0) and then mirror the whole stripe (RAID 1). Same disks and same 50% capacity as RAID 10, but a different failure behaviour (see L4·Q3). RAID 10 is mirror-then-stripe; RAID 0+1 is stripe-then-mirror.

Level 1 — Recognition

Recall Solution L1·Q1

(a) RAID 0 — pure striping. It still stores one copy of every block, but keeps zero redundancy (nothing extra to rebuild from). (b) RAID 1 — mirroring. (c) RAID 5 — striping + one distributed parity. (d) RAID 6 — striping + double distributed parity ( $P$ and $Q$ ). (e) RAID 10 — mirror then stripe.

Recall Solution L1·Q2

(a) False. No redundancy means any single failure loses the whole array. (b) True. Two independent parities → two solvable unknowns. (c) True. Half the disks are copies, so usable $= n /2$ .

Level 2 — Application

Recall Solution L2·Q1

Raw = $10 \times 6 = 60$ TB. Here is why each capacity rule holds, then the number:

RAID 0 → $n$ : every disk holds unique data, nothing wasted → $10 \times 6 = 60$ TB.
RAID 1 → $n /2$ : each disk has an identical twin, so half the disks are pure copies → $\frac{10}{2} \times 6 = 30$ TB.
RAID 5 → $n - 1$ : one disk's worth of space is spent on parity (rotated, not a single disk) → $(10 - 1) \times 6 = 54$ TB.
RAID 6 → $n - 2$ : two disks' worth of space are spent on the two parities $P$ and $Q$ → $(10 - 2) \times 6 = 48$ TB.
RAID 10 → $n /2$ : mirroring already halves usable capacity; striping across the pairs adds speed, not space → $\frac{10}{2} \times 6 = 30$ TB.

Recall Solution L2·Q2

Do it left to right (XOR is associative, so grouping is free): $D_{1} \oplus D_{2} = 1101 \oplus 0011 = 1110$ (bit by bit: 1≠0→1, 1≠0→1, 0≠1→1, 1≠1→0). $1110 \oplus D_{3} = 1110 \oplus 1000 = 0110 = P$ So $P = 0110$ .

Recall Solution L2·Q3

Recovery rule: $D_{1} = P \oplus D_{2} \oplus D_{3}$ . $P \oplus D_{2} = 0110 \oplus 0011 = 0101$ $0101 \oplus D_{3} = 0101 \oplus 1000 = 1101 = D_{1}$ $D_{1} = 1101$ — exactly the original. ✓

Recall Solution L2·Q4

4 I/Os: read old data $D_{o l d}$ , read old parity $P_{o l d}$ , write new data $D_{n e w}$ , write new parity $P_{n e w}$ . Parity is recomputed with $P_{n e w} = P_{o l d} \oplus D_{o l d} \oplus D_{n e w}$ (no need to touch other disks).

Level 3 — Analysis

Recall Solution L3·Q1

To compute correct new parity you must remove the old data's contribution and insert the new one: $P_{n e w} = P_{o l d} \oplus D_{o l d} \oplus D_{n e w}$ This formula needs $P_{o l d}$ and $D_{o l d}$ , and both currently sit on disk — you must read them first. So: read $D_{o l d}$ , read $P_{o l d}$ (2 reads) → then write $D_{n e w}$ , write $P_{n e w}$ (2 writes) = 4 I/Os. The 2 reads are the hidden cost the naïve count forgets.

Recall Solution L3·Q2

RAID 6 keeps two parities $P$ and $Q$ , both of which include the block you changed. Each needs its own read-modify-write:

Read $D_{o l d}$ , $P_{o l d}$ , $Q_{o l d}$ → 3 reads.
Write $D_{n e w}$ , $P_{n e w}$ , $Q_{n e w}$ → 3 writes.

Total = 6 I/Os. That is why RAID 6 is slower on small writes than RAID 5.

Recall Solution L3·Q3

A large sequential read is fast when many disk heads pull data at once. So the question is: for each level, how many spindles feed useful data in parallel?

RAID 0 ≈ $n$ spindles: every disk holds unique data, all $n$ read simultaneously. Nothing wasted → fastest.
RAID 10 ≈ up to $n$ spindles: each mirror pair can serve reads from either twin, so both disks in every pair can stream different parts at once → essentially matches RAID 0.
RAID 5 ≈ $n$ spindles read, but only $n - 1$ carry data in any stripe (one block per stripe is parity). For a pure sequential read the controller still spins all disks, yet the useful-data bandwidth is capped a touch below RAID 0/10 because one disk's worth per stripe is parity, not payload. That is the reason it sits just behind.
RAID 1 (plain mirror, not striped): a single mirror pair only has 2 disks feeding one logical stream, so it does not scale up with large $n$ the way striped levels do → slowest per usable-data.

Ordering, with the symbol $≳$ meaning "about equal to, or slightly faster than": $RAID 0 \approx RAID 10 ≳ RAID 5 > RAID 1 .$ Reads are broadly similar across striped levels; the write side (parity penalty) is the real differentiator.

Recall Solution L3·Q4

RAID 5 has one parity equation, which solves for exactly one unknown disk. While rebuilding the first dead disk, all remaining 11 disks are read hard for hours — stress that raises the chance of a second failure. If a second disk dies before the rebuild finishes, you now have two unknowns but only one equation → unsolvable → total loss. RAID 6 keeps a second, independent parity $Q$ , giving two equations, so it can still solve for two dead disks and survive that scenario. See Reliability and MTBF for the failure-rate reasoning.

Level 4 — Synthesis

Recall Solution L4·Q1

Choose RAID 10. Reasoning:

Write-heavy + small writes → avoid parity's read-modify-write penalty (RAID 5/6 out).
Must survive a disk failure with availability → RAID 0 out.
RAID 10 = mirror then stripe → fast writes (no parity recompute) and redundancy.

Capacity of RAID 10 is $n /2$ disks. Need $20$ TB usable at $4$ TB/disk = $5$ usable data disks → $5$ mirror pairs → $n = 10$ disks (giving $10/2 \times 4 = 20$ TB usable). Round pairs up if odd; here it's exact.

Recall Solution L4·Q2

Choose RAID 6. Reasoning:

Large writes, rare → the parity penalty is amortised over big stripes, and small-write cost is irrelevant.
Cost matters → RAID 6 wastes only 2 disks (vs RAID 10 wasting half).
Must survive during long rebuilds of big disks → need double parity (RAID 5 is unsafe here, see L3·Q4).

RAID 6 usable = $n - 2$ disks. Need $100$ TB at $10$ TB/disk = $10$ usable data disks → $n - 2 = 10 \Rightarrow n = 12$ disks. Usable $= (12 - 2) \times 10 = 100$ TB. ✓

Recall Solution L4·Q3

RAID 10 is more robust.

RAID 10 (mirror-then-stripe): each pair is a mirror. A pair survives as long as one of its two disks lives. Two failures are fatal only if both dead disks are in the same pair. With 4 pairs, the second failure lands in the same pair only ~1 in 7 times → usually survives.
RAID 0+1 (stripe-then-mirror): one disk loss kills its whole stripe, so you are left leaning on the other stripe entirely. A second failure in that surviving stripe kills the array. The window of vulnerability is much wider.

Order matters: mirror-then-stripe localises damage to a single pair.

Level 5 — Mastery

Recall Solution L5·Q1

Start from the right-hand side and substitute $P$ : $P \oplus ⨁_{i \neq = k} D_{i} = (⨁_{all i} D_{i}) \oplus ⨁_{i \neq = k} D_{i} .$ Group each surviving $D_{i}$ ( $i \neq = k$ ) with its copy inside $P$ . By commutativity/associativity we can pair them, and by self-inverse $x \oplus x = 0$ each pair vanishes: $= D_{k} \oplus (⨁_{i \neq = k} (D_{i} \oplus D_{i})) = D_{k} \oplus 0 = D_{k} .$ Only the term with no partner — $D_{k}$ — survives. $■$ This is exactly why single parity fixes exactly one erasure: one equation, one unknown.

Recall Solution L5·Q2

With two dead data disks $D_{a}, D_{b}$ , the survivors give: $P_{1} \oplus ⨁_{i \neq = a, b} D_{i} = D_{a} \oplus D_{b} .$ $P_{2}$ is identical to $P_{1}$ , so it yields the same equation $D_{a} \oplus D_{b}$ . Two copies of one equation is still one equation with two unknowns → infinitely many $(D_{a}, D_{b})$ satisfy it → unrecoverable. RAID 6 instead computes $Q = ⨁_{i} g^{i} \cdot D_{i}$ over GF(2^8), where multiplying $D_{i}$ by a distinct field element $g^{i}$ weights each disk differently. Now the $Q$ equation is linearly independent from the $P$ equation, giving a solvable $2 \times 2$ system → both unknowns recovered.

Recall Solution L5·Q3

(a) RAID 5 with $n = 2$ : parity of a single data block is just a copy of it ( $P = D_{1}$ ). So it degenerates into RAID 1 (mirroring). Usable $= n - 1 = 1$ disk, same as $n /2$ for $n = 2$ . (b) RAID 6, $n = 3$ : usable $= n - 2 = 1$ disk. Two of three disks are parity — extremely wasteful, and the minimum size where RAID 6 even makes sense. (c) $P = 0000 \oplus 0000 \oplus \dots = 0000$ . Parity of all-zero data is zero (identity $x \oplus 0 = x$ ). (d) RAID 1 with $n = 1$ has no twin to mirror onto — it is just a single plain disk, no redundancy. Not a meaningful mirror.

Recall Solution L5·Q4

$P = D_{1} \oplus D_{2} \oplus D_{3} = 1010 \oplus 0111 \oplus 0001.$ Step: $1010 \oplus 0111 = 1101$ . Then $1101 \oplus 0001 = 1100 = P$ . Recover: $D_{3} = P \oplus D_{1} \oplus D_{2} = 1100 \oplus 1010 \oplus 0111$ . $1100 \oplus 1010 = 0110$ ; $0110 \oplus 0111 = 0001 = D_{3}$ . ✓ Matches the original — the round-trip closes.

The failure-survival counting from L4·Q3 is easier to see visually:

Figure — RAID — levels 0, 1, 5, 6, 10 — trade-offs

Recall

What makes a small RAID 5 write cost 4 I/Os?

You must read

D_{o l d}

and

P_{o l d}

before writing

D_{n e w}

and

P_{n e w}

— two hidden reads plus two writes.

Why can single XOR parity recover only one dead disk?

One parity = one equation = one solvable unknown.

Why does RAID 6 use

Q

over

GF (2^{8})

rather than a second XOR?

A second XOR gives the same equation;

Q

weights disks by

g^{i}

to be linearly independent, so two unknowns are solvable.

For a write-heavy DB needing redundancy, which level?

RAID 10 — fast writes (no parity recompute) plus redundancy.

For a cheap large archive that must survive long rebuilds, which level?

RAID 6 — only 2 disks wasted, survives a second failure during rebuild.

Difference between RAID 10 and RAID 0+1?

RAID 10 = mirror then stripe (localises damage to one pair); RAID 0+1 = stripe then mirror (one disk kills a whole stripe).