striped + no redundancy
Derived by hand from the Linux md rule — how the pages are sourced
Data dealt out in chunks across every disk and nothing else: no copy, no parity. Every disk works on every large request, so it is the fastest layout there is and uses all the space; and any one disk failing loses everything on all of them.
RAID 0 is the pair striped + no redundancy: the data is cut into chunks and dealt across the members in turn (striping), and that is all. The 1988 paper that named RAID defines five levels, from mirroring upward; a stripe with no redundancy is not one of them, and the name came later, for exactly the case the paper opens with: an array whose time to failure is one disk's divided by the number of disks (redundancy).
Every advantage of striping, with nothing subtracted. One large request is spread over all N disks and arrives at their combined bandwidth; N small requests at unrelated addresses are served at once; every byte of every disk holds data, so the capacity is the sum. The write penalty is one: a write is one write. No other layout matches it on any of these, which is why it is the reference the others are measured against (performance).
A fault tolerance of zero, and zero is worse than it sounds. A linear array that loses a disk loses the files that were on that disk; a stripe that loses a disk loses every file larger than a chunk, because each of them had a piece there. The array does not become smaller, it becomes unreadable. And the more disks, the sooner: ten disks fail, between them, ten times as often as one.
The level is right for data that can be lost or remade: scratch space for editing, render caches, a build directory, anything whose source is elsewhere. The chunk size is its one parameter, and the only decision after the disk count. Two disks is the minimum, because an array of one member is that member; there is no smaller array it could become.
Linux md calls it raid0 and copes with disks of unequal size by continuing the stripe over the larger ones once the smaller are full (segmentation); Windows Storage Spaces calls it a simple space, "data striped across multiple drives" with "no resiliency or redundancy". JBOD is the linear equivalent: the same absence of redundancy, none of the speed, and a failure that costs the files of one disk instead of all of them.
How an array splits its data across its member disks. Striped cuts the data into fixed-size chunks and deals them out to every member in turn; linear writes it as one run, filling the first member before touching the next. Segmentation is about how many disks take part in one request, not about whether the data survives a failure.
RAID 0 · 4 disks
disk 0 disk 1 disk 2 disk 3
stripe 0 D0 D1 D2 D3
stripe 1 D4 D5 D6 D7
stripe 2 D8 D9 D10 D11
stripe 3 D12 D13 D14 D15How an array keeps its data readable when a member fails: by storing more than the data itself. Two techniques do it. Mirroring keeps whole copies on separate disks; parity keeps a computed summary from which any one missing block, or two with a second parity, can be rebuilt. Redundancy always costs capacity; the question is how much, and how many failures it buys.
N × disk size
N = 4 disks of 2 TB → 4 × 2 TB = 8 TB usable
the members an adversary must kill, minus one
no redundancy: any one member gone kills it → 1 → tolerance 0
one logical write costs
no copies and no parity → 1 I/O, random or sequentialThe rule that says, stripe by stripe, which member holds the parity and where the data starts, or where a mirror's copies go. The level says what is stored; the algorithm says where. Left-symmetric for the parity levels and near for RAID 10 are the defaults nearly everything uses. The choice changes speed and compatibility, not capacity or safety.
Read more — Placement algorithm
a plain stripe has no parity and no copies to place
The component that turns a RAID layout into disk operations. It owns the array's metadata, translates every request from the array's addresses to the members', writes the copies or computes the parity, and keeps serving when a disk fails. It is a role, not a fixed device: a RAID-on-Chip on a controller card, the operating system's own driver, or a boot firmware working with that driver.
Open this example in the sandbox
A desktop link: below the desktop breakpoint the sandbox is not offered (ADR-003).