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 property of striping, with nothing subtracted:
No other layout matches it on any of these, which is why it is the reference the others are measured against (performance).
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 and the same loss of the whole volume when a disk fails, without the speed.
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.
The grid below is the placement of a RAID 0 array of 4 disks, as the Linux md rule produces it. Each column is one disk, each row is one stripe, and each cell names the block that lands there: D followed by a number for a data chunk. Reading a row from left to right shows how one stripe is dealt across the members; reading a column from top to bottom shows what one disk ends up holding.
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 covers.
Three quantities follow from the redundancy alone: usable capacity, fault tolerance and write penalty. Below they are worked out for the example array, 4 disks of 2 TB each. Each block states the general rule on its first line, then substitutes the numbers of the example on the lines that follow.
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 placement algorithm decides where the parity blocks or the copies go within each stripe. RAID 0 has none to choose from: 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.
In any given system, exactly one component holds the role of RAID engine: a hardware controller with its own processor, a firmware chip that keeps the metadata while the operating system's driver does the work, or the operating system alone. They are alternatives, not layers, so a system has one of them and not the others. The list below names the components that can hold that role for a RAID 0 array, and what each of them does with the level.
RAID 0 has nothing below its minimum of 2 disks: an array of one member is that member, so two disks is the smallest array of any kind and no RAID level exists on one disk.
Open this example in the sandbox
A desktop link: on a phone or in a narrow window the sandbox is not offered.