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

4.2.39 · D3 · Coding › Operating Systems › RAID — levels 0, 1, 5, 6, 10 — trade-offs

Hum poore page mein sirf teen tools use karte hain, sab parent note mein banaye hue:

XOR likha jaata hai $\oplus$ — "carry ke bina add karo", jahan $x \oplus x = 0$ (dekho XOR and Boolean Algebra).
Capacity formulas — $0 \to n$ , $1 \to n /2$ , $5 \to n - 1$ , $6 \to n - 2$ , $10 \to n /2$ .
Write-penalty count — small writes = 4 I/Os (RAID 5) ya 6 I/Os (RAID 6).

Kuch naya assume nahi kiya gaya. Neeche har symbol parent note mein kamaya gaya hai.

Scenario matrix

Har RAID problem inhi case classes mein se ek hoti hai. Is page ka goal har cell ko fill karna hai.

#	Case class	Isme tricky kya hai	Worked example
A	Capacity — normal array	level formula mein plug karo	Ex 1
B	Fault tolerance — normal	kitni failures survive hoti hain	Ex 1, Ex 4
C	Degenerate input (chota $n$ )	$n = 2$ , $n = 3$ : formulas limits hit karti hain	Ex 2
D	Zero / impossible input	RAID 6 with 2 disks = "no data disks"	Ex 3
E	XOR recovery — data disk dies	ek data block rebuild karo	Ex 5
F	XOR recovery — parity disk dies	parity khud lost ho jaati hai	Ex 5
G	Small-write I/O count	read-modify-write penalty	Ex 6
H	Limiting behaviour (bada $n$ )	efficiency jab $n \to \infty$	Ex 7
I	Second-failure-during-rebuild	kyun RAID 5 bade arrays par mar jaata hai	Ex 8
J	Real-world word problem	requirements se level chuno	Ex 9
K	Exam twist (RAID 0+1 vs 10)	operations ka order fate badal deta hai	Ex 10

Neeche ke examples is order mein hain taaki saath milke woh A se K tak cover karen.

Worked examples

Worked example Ex 1 — Cell A + B: normal array ki capacity aur tolerance

Statement. Tumhare paas $n = 6$ disks hain, har ek $2$ TB. RAID 0, 1, 5, 6, 10 ke liye usable capacity aur max failures survived do.

Forecast: padhne se pehle paanch capacities guess karo — kaun sa level sabse zyada space waste karta hai?

RAID 0: capacity $= n \times 2 = 6 \times 2 = 12$ TB. Yeh step kyun? striping har disk ko data ke liye rakhta hai.
RAID 1: capacity $= \frac{n}{2} \times 2 = 3 \times 2 = 6$ TB. Kyun? aadhi disks exact copies hain.
RAID 5: capacity $= (n - 1) \times 2 = 5 \times 2 = 10$ TB. Kyun? ek disk ke barabar parity $P$ hai.
RAID 6: capacity $= (n - 2) \times 2 = 4 \times 2 = 8$ TB. Kyun? do disks ke barabar $P$ aur $Q$ hain.
RAID 10: capacity $= \frac{n}{2} \times 2 = 6$ TB. Kyun? mirroring ise aadha karti hai; striping capacity add nahi karti.

Failures survived — guaranteed aur lucky ko alag karo:

RAID 0 → 0 (guaranteed aur best-case: bilkul redundancy nahi).
RAID 5 → 1 (guaranteed aur best-case: single parity).
RAID 6 → 2 (guaranteed aur best-case: double parity).
RAID 1 & 10 (yahan 3 mirror pairs) → worst-case guaranteed = 1 (ek single failure hamesha survive hoti hai; usi pair mein do failures use kill karti hain). Best-case (lucky) = 3 (har 3 pairs mein se ek disk mar sakti hai aur har pair ke paas twin bacha rahega). Honest headline number guaranteed 1 hai.

Verify: total raw $6 \times 2 = 12$ TB hai. RAID 5 rakhta hai $10/12 = 83.3%$ ; RAID 6 rakhta hai $8/12 = 66.7%$ ; RAID 1/10 rakhte hain $50%$ . Parity hamesha mirroring se sasta hai — theory se match karta hai. ✓

Worked example Ex 2 — Cell C: sabse chote legal arrays (degenerate small

$n$ ) Statement. Kya hota hai jab har level apne minimum disk count par ho? Jo minimum $n$ each level allow karta hai woh use karo.

Forecast: $n = 2$ par, kya RAID 5 possible bhi hai?

RAID 0, $n = 2$ : capacity $= 2$ disks. Kyun? striping ko sirf $\geq 2$ disks chahiye stripe karne ke liye.
RAID 1, $n = 2$ : capacity $= n /2 = 1$ disk. Kyun? ek twin pair; tumhare paas exactly ek disk data hai.
RAID 5, $n = 3$ (minimum): capacity $= n - 1 = 2$ disks. Kyun? $\geq 2$ data disks + 1 parity worth rotated chahiye. $n = 2$ par tumhare paas $1$ data + $1$ parity hogi = ek mirror disguise mein, isliye RAID 5 ko $n \geq 3$ chahiye.
RAID 6, $n = 4$ (minimum): capacity $= n - 2 = 2$ disks. Kyun? $\geq 2$ data disks plus $P$ aur $Q$ worth chahiye.
RAID 10, $n = 4$ (minimum): capacity $= n /2 = 2$ disks. Kyun? kuch stripe karne ke liye $\geq 2$ mirror pairs chahiye.

Verify: RAID 5 apne floor $n = 3$ par $2/3 = 66.7%$ rakhta hai — bade arrays se buri efficiency. Chote parity arrays proportionally zyada waste karte hain. ✓ (Yahi poora reason hai kyun RAID 5 sirf zyada disks ke saath payoff deta hai.)

Worked example Ex 3 — Cell D: impossible / zero-data input

Statement. Ek student sirf 2 disks ke saath RAID 6 configure karta hai. Usable capacity kya hai, aur number ka matlab kya hai?

Statement. Padhne se pehle $n = 2$ ko $n - 2$ mein plug karo. Kya milta hai, aur kya yeh real hai?

Formula apply karo: capacity $= (n - 2)$ disks $= (2 - 2) = 0$ disks. Yeh step kyun? RAID 6 hamesha do disks' worth $P$ aur $Q$ par spend karta hai.
$0$ interpret karo: zero data capacity — dono disks poori tarah parity hain, actual data ke liye koi jagah nahi. Kyun? minimum $2$ data disks aur $2$ parities chahiye, isliye $\geq 4$ disks chahiye.
Conclusion: RAID 6 with $n < 4$ valid configuration nahi hai — controller ise reject karta hai. Kyun? ek code jo 2 erasures se protect karta hai, use protect karne ke liye kam se kam 2 cheezein chahiye.

Verify: formula gracefully $0$ return karta hai, honest answer: "koi usable space nahi." RAID 5 check karo $n = 1$ ke saath: $(1 - 1) = 0$ bhi — ek single disk data aur parity dono store nahi kar sakti. Degenerate inputs $0$ dete hain, negatives nahi. ✓

Worked example Ex 4 — Cell B:

kaun se failure patterns survive karte hain Statement. RAID 10 with 3 mirror pairs (6 disks: pairs ${1, 2}, {3, 4}, {5, 6}$ ). Kaun si 2-disk failures survive karti hain, kaun si nahi?

Forecast: RAID 10 "1 per pair survive karta hai" — toh kya yeh hamesha 2 failures survive karta hai?

${1, 3}$ ki failure (do alag pairs mein se ek ek): survive karta hai. Kyun? har pair ke paas ek living twin bacha rahta hai.
${1, 2}$ ki failure (ek pair ke dono disks): total loss. Kyun? us pair ke data ki koi surviving copy nahi hai.
Survivable 2-disk sets count karo: disks ke total pairs $= (2 6) = 15$ . Fatal wale 3 within-pair combos hain. Survivable $= 15 - 3 = 12$ . Yeh step kyun? sirf same-pair losses fatal hain.

Verify: random 2-disk failure ki survival probability $= 12/15 = 0.8 = 80%$ . RAID 6 se compare karo: sab $(2 6) = 15$ do-disk failures survive karta hai (100%). Toh RAID 6 2 failures ke against strictly safer hai, lekin RAID 10 faster write karta hai. Parent trade-off table se match karta hai. ✓

Worked example Ex 5 — Cells E + F: XOR recovery, data disk

aur parity disk Statement. Ek RAID 5 stripe mein $D_{1} = 1101$ , $D_{2} = 0011$ , $D_{3} = 1010$ hain. Parity $P = D_{1} \oplus D_{2} \oplus D_{3}$ . (a) $D_{2}$ recover karo agar disk 2 mar jaaye. (b) $P$ recover karo agar parity disk mar jaaye.

Forecast: case (b) mein, kya parity kho jaana data padhne ke liye problem bhi hai?

$P$ compute karo: $D_{1} \oplus D_{2} = 1101 \oplus 0011 = 1110$ . Kyun? pehle do blocks combine karo.
Finish: $P = 1110 \oplus D_{3} = 1110 \oplus 1010 = 0100$ . Kyun? parity complete karne ke liye last block XOR karo.
(a) Data disk dies. $D_{2} = P \oplus D_{1} \oplus D_{3}$ recover karo. Kyun? recovery rule har surviving block ko cancel karta hai, missing wala bacha rehta hai.
$P \oplus D_{1} = 0100 \oplus 1101 = 1001$ ; phir $1001 \oplus D_{3} = 1001 \oplus 1010 = 0011 = D_{2}$ . Kyun? original $D_{2}$ se match karta hai — recovery successful.
(b) Parity disk dies. Data $D_{1}, D_{2}, D_{3}$ seedha readable hain — padhne ke liye koi rebuild nahi chahiye. Redundancy restore karne ke liye, $P = D_{1} \oplus D_{2} \oplus D_{3} = 0100$ recompute karo (step 2). Kyun? parity sirf data ka ek function hai; kisi bhi waqt recompute kar lo.

Figure padhein. Char boxes hain — teen data blocks (blue) aur parity block $P$ (green), har ek apni 4-bit value dikhata hai. Red X dead disk $D_{2}$ mark karta hai. Neeche, do green monospace lines follow karo: woh exactly steps 3–4 hain — pehle $P \oplus D_{1} = 1001$ , phir $\oplus D_{3} = 0011$ , jo original $D_{2}$ par land karta hai. Caption remind karta hai kyun yeh round-trip karta hai: har surviving block do baar appear karta hai aur cancel ho jaata hai ( $x \oplus x = 0$ ), sirf missing wala bacha rehta hai.

Verify: recovered $D_{2} = 0011$ original ke barabar hai. Recomputed $P = 0100$ stored parity ke barabar hai. Dono perfectly round-trip karte hain kyunki XOR self-inverse hai ( $x \oplus x = 0$ ). ✓ RAID 6 ki second parity $Q$ ko XOR se zyada kyun chahiye, iske liye dekho Galois Fields GF(2^n).

Worked example Ex 6 — Cell G: RAID 5 vs RAID 6 mein small write ki I/O cost

Statement. Ek 4 KB data block update karo. RAID 5 aur RAID 6 ke liye physical disk I/Os count karo. Phir dono parities update karo: $P_{n e w} = P_{o l d} \oplus D_{o l d} \oplus D_{n e w}$ use karo jahan $P_{o l d} = 0100$ , $D_{o l d} = 0011$ , $D_{n e w} = 1111$ , aur RAID 6 second parity $Q$ ko analogous tarike se update karo.

Forecast: compute karne se pehle do I/O counts guess karo, aur $P_{n e w}$ guess karo.

RAID 5 I/Os: read $D_{o l d}$ (1), read $P_{o l d}$ (1), write $D_{n e w}$ (1), write $P_{n e w}$ (1) $= 4$ . Kyun? parity ko valid rehne ke liye recompute karna padta hai, aur uske liye old values chahiye.
RAID 6 I/Os: same reads/writes lekin do parities $P$ aur $Q$ ke liye: read $D_{o l d}, P_{o l d}, Q_{o l d}$ (3), write $D_{n e w}, P_{n e w}, Q_{n e w}$ (3) $= 6$ . Kyun? ek second independent parity parity work double karti hai.
$P_{n e w}$ compute karo: $P_{o l d} \oplus D_{o l d} = 0100 \oplus 0011 = 0111$ . Kyun? parity se old data ka contribution remove karta hai.
$P_{n e w}$ finish karo: $P_{n e w} = 0111 \oplus D_{n e w} = 0111 \oplus 1111 = 1000$ . Kyun? new data ka contribution insert karta hai.
Second parity $Q$ update karo (sirf RAID 6 mein). $Q$ plain XOR nahi hai — parent note se $Q = ⨁_{i} g^{i} \cdot D_{i}$ over $GF (2^{8})$ , toh position $i$ wala block $g^{i}$ se multiply hokar enter karta hai. Wahi "remove-old, add-new" trick kaam karti hai, lekin change us block ke coefficient se scale karna padta hai: $Q_{n e w} = Q_{o l d} \oplus (g^{i} \cdot D_{o l d}) \oplus (g^{i} \cdot D_{n e w}) .$ Yeh step kyun? $Q_{o l d}$ mein term $g^{i} \cdot D_{o l d}$ thi; use wapas XOR karne se woh cancel ho jaati hai ( $x \oplus x = 0$ ), aur $g^{i} \cdot D_{n e w}$ XOR karne se new scaled term insert hoti hai. Numerically, agar disk $i$ ka coefficient $g^{i} = 1$ hai (sabse simple case, position $0$ ) toh update collapse hokar $P$ jaise shape le leta hai: $Q_{n e w} = Q_{o l d} \oplus D_{o l d} \oplus D_{n e w} = 1000$ same operands ke liye. Kisi bhi doosri position ke liye multiply $GF (2^{8})$ mein hoti hai — dekho Galois Fields GF(2^n).

Verify: $P_{n e w}$ ko scratch se rebuild karke sanity-check karo. Maano stripe thi $D_{o l d} = 0011$ jisme do doosre blocks $0111$ tak XOR karte hain (kyunki $0111 \oplus 0011 = 0100 = P_{o l d}$ ✓). Write ke baad woh do blocks unchanged hain, toh new full parity $= 0111 \oplus 1111 = 1000 = P_{n e w}$ . ✓ $Q$ ke liye coefficient $g^{i} = 1$ ke saath, shortcut deta hai $Q_{n e w} = 1000$ , same collapsed sum ki scratch se recompute se match karta hai. Dono methods agree hain — shortcut ne doosri disks padhne ki zaroorat bachaai. ✓

Worked example Ex 7 — Cell H: limiting behaviour, efficiency jab

$n \to \infty$ Statement. RAID 5, 6, aur 1 ke liye, jab disks ki sankhya $n$ badhti hai toh raw capacity ka kitna fraction usable hota hai?

Forecast: kya RAID 5 ki efficiency $100%$ approach karti hai? Kya RAID 1 kabhi improve hota hai?

RAID 5 efficiency: $\frac{n - 1}{n} = 1 - \frac{1}{n}$ . Jab $n \to \infty$ , yeh $\to 1$ (yani $100%$ ). Kyun? ek fixed parity disk ek huge array mein negligible ho jaati hai.
RAID 6 efficiency: $\frac{n - 2}{n} = 1 - \frac{2}{n} \to 1$ bhi. Kyun? do fixed parities bhi proportionally vanish ho jaati hain.
RAID 1 efficiency: $\frac{n /2}{n} = \frac{1}{2}$ , constant. Kyun? har disk ka hamesha ek twin hota hai, chahe kitni bhi add karo — mirroring kabhi sasti nahi hoti.
$n = 10$ par numerical spot-check: RAID 5 $= 9/10 = 90%$ ; RAID 6 $= 8/10 = 80%$ ; RAID 1 $= 50%$ . Kyun? limit se pehle trend confirm karta hai.

Figure padhein. Horizontal axis disk count $n$ hai; vertical axis raw capacity ka usable fraction hai. Blue curve RAID 5 $= (n - 1) / n$ hai aur orange curve RAID 6 $= (n - 2) / n$ — dono dashed gray line $1.0$ ( $100%$ ceiling) ki taraf climb karti hain jab tum right move karte ho, steps 1–2 confirm karta hai. Flat green line $0.5$ par baithti hai: woh RAID 1 hai, jo chahe kitna bhi right dekho kabhi improve nahi hota (step 3). Arrow " $\to 1$ as $n \to \infty$ " trend mark karta hai parity curves ke liye.

Verify: limit $1 - 1/ n \to 1$ monotone increasing hai — parity RAID scale ke saath zyada space-efficient hoti hai, jabki mirroring $0.5$ par flat rehti hai. Yahi exactly reason hai kyun huge arrays parity levels prefer karti hain. ✓

Worked example Ex 8 — Cell I: rebuild ke dauran second-failure disaster

Statement. RAID 5 with 12 disks. Ek failure ke baad rebuild ke dauran, baaki har disk ko fully read karna padta hai. Agar us window mein doosri disk fail ho jaaye, toh kya lost hota hai — aur RAID 6 outcome kaise badalta hai?

Forecast: kya disks ki sankhya rebuild ke dauran second failure zyada ya kam likely banati hai?

RAID 5 exactly 1 failure survive karta hai (single parity $P$ = ek equation, ek unknown). Kyun? ek erasure code ek erasure fix karta hai.
Rebuild ke dauran, sab $11$ surviving disks heavy load mein end-to-end read hoti hain. Kyun? missing disk ka har block $D_{k} = P \oplus ⨁_{i \neq = k} D_{i}$ ke zariye recompute hota hai.
Zyada disks ke saath, probability badh jaati hai ki is stressful window mein koi doosri disk fail ho (zyada disks = zyada chances). Kyun? independent failure risks add up hote hain — dekho Reliability and MTBF.
Ab doosri failure matlab do unknowns lekin sirf ek equation → unsolvable → total data loss. Kyun? ek parity do missing blocks span nahi kar sakti.
RAID 6 fix: $P$ aur $Q$ (do independent equations) ke saath doosri failure survive karta hai — rebuild safely continue hoti hai. Kyun? do equations do unknowns solve karti hain.

Verify: RAID 5 tolerance $= 1$ , RAID 6 tolerance $= 2$ ; har ek ko kill karne wali failure count $2$ aur $3$ respectively hain. Toh parent note ki "12-disk RAID 5" mistake confirm hoti hai: bade arrays ko RAID 6 chahiye. ✓

Worked example Ex 9 — Cell J: real-world word problem (level chuno)

Statement. Ek hospital ko ek database volume chahiye jo (i) write-heavy ho, (ii) ek disk failure ke saath no downtime mein survive kare, (iii) exactly 8 × 4 TB disks ka budget ho. Use max capacity nahi chahiye. Kaun sa level, aur kya capacity result hogi?

Forecast: RAID 5 ya RAID 10 — write-heavy ke liye kaun jeetega?

RAID 0 rule out karo — requirement (ii) redundancy demand karta hai. Kyun? RAID 0 0 failures survive karta hai.
RAID 5 aur RAID 10 ke beech: RAID 5 small writes cost karta hai 4 I/Os (read-modify-write); RAID 10 writes cost karta hai 2 I/Os (dono twins ko write karo, parity read nahi). Kyun? write-heavy load mein parity penalty deciding factor hoti hai.
Lowest write penalty aur no-downtime redundancy ke liye RAID 10 choose karo. Kyun? yeh (i) aur (ii) satisfy karta hai; (iii) meet hota hai aur max capacity required nahi hai.
Capacity $= \frac{n}{2} \times 4 = 4 \times 4 = 16$ TB. Kyun? mirroring raw $32$ TB ko aadha karta hai.

Verify: RAID 10 write I/Os $= 2 < 4 =$ RAID 5 — write-heavy ke liye correct. Capacity $16$ TB $\leq 32$ TB raw, $50%$ mirroring overhead se consistent. Teeno requirements meet hoti hain. ✓ (RAID availability hai, backup nahi — hospital ko alag backups bhi chahiye.)

Worked example Ex 10 — Cell K: exam twist, RAID 10 vs RAID 0+1

Statement. 4 disks, do tarike se arrange kiye. RAID 10 = mirror pairs ${A_{1}, A_{2}}, {B_{1}, B_{2}}$ phir stripe. RAID 0+1 = do stripes $S_{1} = {A_{1}, B_{1}}$ , $S_{2} = {A_{2}, B_{2}}$ phir stripes mirror. Disk $A_{1}$ fail hoti hai, phir disk $B_{2}$ fail hoti hai. Kaun sa layout survive karta hai?

Forecast: same disks, same 50% capacity — surely same survival? (Aisa nahi hai.)

RAID 10 $A_{1}$ ke marne ke baad: pair ${A_{1}, A_{2}}$ ke paas abhi bhi $A_{2}$ hai; pair ${B_{1}, B_{2}}$ intact hai. Kyun? mirror-then-stripe redundancy har pair ke andar rakhta hai.
RAID 10 phir $B_{2}$ marti hai: pair ${B_{1}, B_{2}}$ ke paas abhi bhi $B_{1}$ hai. Dono pairs alive hain → survive karta hai. Kyun? do failures alag pairs mein lagin, aur har pair ko sirf ek surviving twin chahiye.
RAID 0+1 $A_{1}$ ke marne ke baad: stripe $S_{1} = {A_{1}, B_{1}}$ broken hai — ek stripe ki andar koi redundancy nahi hoti, isliye koi bhi ek member kho jaaye toh poori stripe khatam. System ab poori tarah surviving mirror copy, stripe $S_{2}$ par depend karta hai. Kyun? stripe-then-mirror redundancy sirf do stripes ke beech rakhta hai, unke andar kabhi nahi.
RAID 0+1 phir $B_{2}$ marti hai: $B_{2} \in S_{2}$ , toh stripe $S_{2}$ ab bhi broken hai. Dono stripes dead hain aur koi teesri copy nahi → total data loss. Kyun? single surviving redundant copy ( $S_{2}$ ) khud ek fragile stripe thi, aur ek disk loss ne use destroy kar diya.

Answer: identical failures ${A_{1}, B_{2}}$ ke saath, RAID 10 survive karta hai lekin RAID 0+1 lost ho jaata hai.

Figure padhein. Top row = RAID 10: do mirror pairs side by side draw kiye hain; $A_{1}$ aur $B_{2}$ par red X hain lekin har pair abhi bhi ek blue (alive) twin dikhata hai, isliye green label padhta hai "BOTH PAIRS OK → SURVIVES". Bottom row = RAID 0+1: same do dead disks ab alag stripes $S_{1}$ aur $S_{2}$ mein hain, isliye dono stripe labels red ho jaate hain ("BROKEN") aur red verdict padhta hai "BOTH STRIPES DEAD → TOTAL LOSS". Ek single caption moral batata hai: striping vs mirroring ka order fault tolerance badal deta hai.

Verify: identical disk failures ${A_{1}, B_{2}}$ → RAID 10 jeeta hai, RAID 0+1 mar jaata hai. Striping vs mirroring ka order genuinely fault tolerance badal deta hai. Yeh parent ke "order matters" mistake ko confirm karta hai. ✓

Recall Quick self-test

RAID 6 with 2 disks — usable capacity? ::: 0 disks (invalid config; dono parity hain). RAID 5 efficiency jab n→∞? ::: 100% approach karta hai, kyunki (n−1)/n → 1. RAID 10, 3 pairs — random 2-disk failures ka kitna fraction survive hota hai? ::: 12/15 = 80%. Small RAID 6 write mein kitne I/Os lagte hain? ::: 6 (data, P, aur Q ka read+write). P_new for P_old=0100, D_old=0011, D_new=1111? ::: 1000. RAID 10 (3 pairs) mein guaranteed vs lucky failures survived? ::: Guaranteed 1 (worst case), up to 3 (ek per pair, best case). RAID 0+1 wahin kyun marti hai jahan RAID 10 survive karta hai (same disks)? ::: Stripe-then-mirror ke andar ek stripe mein redundancy nahi hoti; ek loss poori stripe tod deta hai.

Back to the RAID overview · related: Disk Scheduling, File Systems, Reliability and MTBF.