PlatinumRAID Owner’s Manual
RAID 50
A RAID 50 array is formed using a two-layer hierarchy of RAID types. At the lowest
level of the hierarchy is a set of RAID 5 arrays. These RAID 5 arrays in turn are then striped to
form a RAID 0 array at the upper level of the hierarchy. The collective result is a RAID 50 array.
The figure below demonstrates a RAID 50 comprised of two RAID 5 arrays at the lower level of
the hierarchy – arrays X and Y. These two arrays in turn are striped using 4 stripes (comprised
of the strips 1X, 1Y, 2X, 2Y, etc.) to form a RAID 0 at the upper level of the hierarchy. The result
is a RAID 50.
Advantage:
RAID 50 ensures that if one of the disks in any parity group fails, its
contents can be extracted using the information on the remaining functioning disks in its parity
group. Thus it offers better data redundancy than the simple RAID types, i.e., RAID 1, 3, and 5.
Also, a RAID 50 array can improve the throughput of read operations by allowing reads to be
performed concurrently on multiple disks in the set.
Read Ahead
Motivated by the principle of “spatial locality”, many RAID controllers read
blocks of data from secondary storage ahead of time, i.e., before an application actually
requests those blocks. The number of data blocks that are read ahead of time is typically
governed by some heuristic that observes the pattern of requests. The read-ahead technique
is particularly efficient when the spatial distribution of an application’s requests follows a
sequential pattern.
Read Around
When using this methodology, a read operation circumvents the cache and
directly reads data from secondary storage into system memory.
Read-Modify-Write
This is a term used to characterize an efficient methodology using
which parity is calculated and written into a RAID array. However, before we describe this
methodology, let us briefly touch upon the most obvious and brute-force way of determining
and writing parity (in response to a write operation) into a RAID array. Assume that data is
being written into a strip on the RAID array that supports redundancy by the use of parity. Let
us denote this as the target strip. Also assume that there are N strips per stripe including the
parity strip and the target strip. Then to recalculate parity for that stripe, the following steps
may be taken. First the contents of the N – 2 non-parity strips (belonging to the same stripe as
the target strip) have to be read. This is followed by N – 2 XOR operations on the contents of
the N – 2 strips that were just read plus the new contents of the target strip. This is followed
by 1 operation to write the new data into the target strip and 1 operation to update the value
of the parity strip. In all the total number of read, XOR and write operations are N – 2, N – 2,
and 2 respectively adding up to a grand total of 2N – 2. Let us now discuss the “read-modify-
write” method for calculating and writing parity. It is based on simple algebra, and is more
efficient than the method described earlier when the value of N is large. Suppose d1, d2,…
dt,… dN-1 are the data contents of the N – 1 non-parity strips with dt being the contents of
the target strip. Let, p = d1 ^ d2 ^ … dt ^ …^ dN-1 Now suppose that the new data to be
written into the target strip is d’t.We wish to determine the value of p’ = d1 ^ d2 ^ … d’t ^
…^ dN-1. Now, p ^ p’ = (d1 ^ d2 ^ … dt ^ …^ dN-1) ^ (d1 ^ d2 ^ … d’t ^ …^ dN-1) p ^ p’
= dt ^ d’t, since ^ operation is commutative and associative p’ = dt ^ d’t ^ p In other words,
the new parity can be evaluated by calculating the XOR of the old data in the target strip, the
new data for the target strip and the old parity. Clearly this requires only 2 reads – one for the
old data and the old parity – followed by 2 XOR operations with 2 writes – one for writing
the new data into the target strip and the new parity, giving us a grand total of 6 operations.
Why is this better? When the value of N is large, i.e., the size of the parity group is large; the
brute-force method utilizes far more operations!
D-Glossary