RAID Capacity Calculator

Background.

A RAID array never gives you the capacity you bought, and it fails to do so twice over. The first loss is deliberate: redundancy costs drives, and the RAID level you pick decides how many. The second loss is an accounting artefact, and it catches far more people out — a drive sold as 4 TB holds four trillion bytes, but your operating system divides by 2⁴⁰ rather than 10¹², prints 3.64, and still writes 'TB' next to it. This calculator shows both numbers side by side for RAID 0, 1, 5, 6, 10, 50 and 60, so the figure on the quotation and the figure in the disk manager stop looking like a contradiction.

The capacity rules themselves are simple arithmetic once you know which one applies. Striping keeps everything: RAID 0 gives you N drives of space and zero protection. Mirroring keeps one drive's worth however many copies you add, so a three-way mirror of 4 TB drives is still a 4 TB volume. Single parity — RAID 5 — costs one drive; dual parity — RAID 6 — costs two, regardless of how wide the array is, which is why parity efficiency improves as you add members while mirroring efficiency gets steadily worse. RAID 10 halves the pool. The spanned levels, RAID 50 and RAID 60, are a RAID 0 stripe laid over several RAID 5 or RAID 6 groups, so they cost one or two drives per span rather than per array: twelve drives in two RAID 6 spans lose four, and in three spans they lose six.

Fault tolerance is where most capacity planning quietly goes wrong, and it is why this page reports two failure numbers rather than one. RAID 6 survives any two drives failing, full stop. RAID 10 is routinely described as surviving half the array, and it can — but only if every failure lands in a different mirrored pair. Lose both halves of one pair and the volume is gone, whichever other drives are still spinning. The same asymmetry applies to RAID 50 and RAID 60: the guaranteed figure is the per-span figure, and the impressive figure is the lucky one. When you are sizing a rebuild window or writing a risk register, the guaranteed number is the only one that means anything.

A few things this calculator deliberately does not pretend to know. It will not estimate rebuild time or the probability of a second failure during a rebuild, because both depend on the specific drive's unrecoverable-read-error rate and the controller's rebuild throughput, and inventing those figures would be worse than omitting them. It assumes identically sized members, because every RAID level truncates larger drives down to the smallest one — the Linux md documentation puts it plainly: only the amount of space available on the smallest device is used. And it excludes hot spares from the drive count, since a spare contributes no capacity until it has been rebuilt into the array. Everything below the widget — the per-level derivation, the worked example, the decimal-versus-binary explanation — is sourced to a storage vendor's own documentation or to a standards body, and named as such.

What is raid capacity calculator?

RAID capacity is the amount of space a filesystem can actually use on an array, as distinct from the raw capacity of the drives fitted. The difference is the redundancy overhead, and it is fixed by the RAID level. RAID 0 stripes data across all members with no redundancy, so usable equals raw and any single drive failure destroys the array. RAID 1 writes a complete copy to every member, so usable capacity equals one drive regardless of how many mirrors exist, and the array survives all but one drive. RAID 5 stripes data with one drive's worth of distributed parity, giving N−1 drives of usable space and tolerance of one failure. RAID 6 adds a second, independent parity, giving N−2 drives and tolerance of two failures. RAID 10 stripes across mirrored pairs, giving half the raw pool. RAID 50 and RAID 60 are stripes laid across several RAID 5 or RAID 6 spans, costing one or two drives per span. Separately from the RAID arithmetic, the same byte count can be written two ways. Storage vendors use decimal SI prefixes — a terabyte is 10¹² bytes — while operating systems divide by powers of two, so the same array reads as roughly 9.1% smaller in TiB than in TB and around 7.4% smaller in GiB than in GB. The binary prefixes kibi, mebi, gibi and tebi were standardised precisely to remove that ambiguity, and this calculator shows both forms so you never have to guess which one a tool meant.

How to use this calculator.

1. 01Pick the RAID level. If you are comparing options, run the calculator several times — the point of the page is that the same drives give very different volumes at different levels.
2. 02Enter the number of member drives. Exclude hot spares: a spare is idle capacity until a rebuild consumes it, and counting it inflates every figure on the page.
3. 03Enter the capacity of the smallest drive, not the largest and not the average. Every RAID level truncates larger members down to the smallest one, and the wasted remainder is invisible until you look for it.
4. 04Choose the unit you typed. Use TB or GB if you copied the number off the box or the invoice, because storage vendors use decimal prefixes. Use TiB or GiB if you copied it out of an operating system or a controller UI.
5. 05Set the span count only if you chose RAID 50 or RAID 60. The drive count has to divide evenly by it, each RAID 5 span needs at least three drives, and each RAID 6 span needs at least four. More spans means more redundancy overhead but better luck-case survival.
6. 06Read the two capacity figures together. The decimal TB figure is what to check against a quotation; the TiB figure is what your monitoring will alert on. Then read the guaranteed failure count — not the best-case one — when you decide whether the level is good enough.

The formula.

Start by turning the drive size into bytes, because that is the only representation both unit systems agree on. A drive typed as 4 TB is 4 × 10¹² = 4,000,000,000,000 bytes; typed as 4 TiB it is 4 × 2⁴⁰ = 4,398,046,511,104 bytes. Everything downstream is exact integer arithmetic on that byte count, carried at full precision and rounded once at the end.

Next, work out how many drives' worth of capacity the level leaves you. RAID 0 leaves all N. RAID 1 leaves exactly one, because every member holds a complete copy — adding a third mirror buys another drive of tolerance, not another byte of space. RAID 5 leaves N−1: one drive's worth of parity is distributed across the members rather than sitting on a dedicated disk, but the cost is the same one drive. RAID 6 leaves N−2, because it computes two mathematically independent parities. RAID 10 leaves N÷2, since every block is written to two different devices.

The spanned levels follow from those two facts plus one more. A RAID 50 is a RAID 0 stripe over s separate RAID 5 groups; a RAID 60 is a RAID 0 stripe over s RAID 6 groups. Each RAID 5 span of n drives yields n−1, each RAID 6 span yields n−2, and the stripe on top adds no overhead of its own. So RAID 50 yields s × (n−1) = N − s, and RAID 60 yields s × (n−2) = N − 2s. The RAID 50 result is worth noticing: it reproduces exactly the published capacity rule 'N minus the number of logical drives', which is the check that the derivation is sound rather than plausible.

Multiply the usable drive count by the byte capacity of one drive to get usable bytes, subtract that from raw bytes to get the redundancy overhead, and divide usable by raw for the efficiency percentage. Then present the byte figure twice: divided by 10¹² for the decimal terabytes on the invoice, and divided by 2⁴⁰ for the tebibytes the operating system prints. The ratio between them is fixed at 10¹² ÷ 2⁴⁰ ≈ 0.909, so a decimal terabyte is always about 9.1% smaller than a tebibyte, and the gap widens at every step up the ladder — it is only about 2.4% at kilo, 4.9% at mega, 7.4% at giga and 9.95% at peta.

Finally, the two fault-tolerance figures. The guaranteed count is how many arbitrary drives can fail before the volume is lost: 0 for RAID 0, N−1 for RAID 1, 1 for RAID 5, 2 for RAID 6, and — importantly — 1 for RAID 10 and RAID 50 and 2 for RAID 60, because a second arbitrary failure may land in the mirror or span that is already degraded. The best-case count assumes the failures spread perfectly across spans: N÷2 for RAID 10, s for RAID 50 and 2s for RAID 60. Both are printed because both are true, and confusing them is the single most common way a RAID design gets signed off on optimism.

A worked example.

Frequently asked questions.

References& sources.

1. [1]Oracle. Sun StorEdge 3000 Family RAID Basics, Appendix A. Source of the per-level capacity table used here: RAID 0 capacity 'N'; RAID 1 usable capacity 'equivalent to the capacity of one drive'; RAID 5 capacity 'N-1'; RAID 50 capacity 'N - # of logical drives'. Also the source for the minimum and maximum member counts quoted for RAID 0 and RAID 5.
2. [2]Linux kernel. md(4) manual page — the manual for the kernel's own software RAID driver. Source of the fault-tolerance figures ('all but one (N-1) for RAID level 1', 'this number is one for RAID levels 4 and 5', 'two for RAID level 6'), the RAID 6 capacity rule ('it requires N+2 drives to store N drives worth of data'), the two-replica RAID 10 capacity example ('space equivalent to 2.5 of the devices will be available'), and the mixed-drive-size rule that only the space on the smallest device is used.
3. [3]Dell. PowerEdge RAID Controller 9 User's Guide (H330, H730, H830), 'Spanned RAID levels'. Source of the structural definition this page derives the RAID 50 and RAID 60 capacity formulas from: 'a RAID 10 has multiple sets of RAID 1 arrays where each RAID 1 set is considered a span', and 'RAID 50 and RAID 60 combine multiple sets of RAID 5 or RAID 6 respectively with striping'.
4. [4]National Institute of Standards and Technology. Prefixes for binary multiples (Reference on Constants, Units and Uncertainty), citing IEC 60027-2 second edition, 2000-11. Source of Ki = 2¹⁰, Mi = 2²⁰, Gi = 2³⁰, Ti = 2⁴⁰, and of the statement that manufacturers of computer storage devices usually use megabyte to mean 1,000,000 bytes while memory manufacturers use 2²⁰ = 1,048,576 bytes.