Lecture 41

Assignment Questions

Redundant Arrays of Inexpensive Disks (RAID)

• Because of the actual implementation costs of RAID, people now call this Redundant Arrays of Independent Disks, however that is a complete misnomer.

• RAID was introduced in Patterson, D.A., Gibson, G.A., Katz, R.H., A case for redundant arrays of inexpensive disks (RAID), Proceedings of the 1988 ACM SIGMOD International Conference on Management of Data, 1988, 109-116. In that paper, Patterson et al., noted that if one has an array of independent disks, one can expect a failure every MTTF_Array = MTTF_Single_Disk/Num_Disks. Thus, if one has a disk that fails on average every 30000 hours, an array of 100 disks can be expected to fail every 300 hours, or every two weeks. This is not the point of RAID!

• The whole point of RAID is to make the disks dependent on each other, to represent information redundantly.

• There is but one fundamental method to maintain redundancy, and that is to use parity bits, that is to store a bit that brings the total number of one bits in a represented datum to either an odd or even number.

• RAID provides various levels of redundancy based on the type of parity information that is maintained.

• Within each RAID level, one can calculate the MTTF by considering how many data disks D appear in an array, the number of parity groups nG used in the array, how may disks G are used to store a datum in any parity group, and how many disks C are used to store check or parity bits for that group.

  Under these conditions, the MTTF of a group of disks is given by

  
  MTTF_Group = (MTTF_Disk/G+C)*(1/Probability of another failure
                                            in the group before repair)
  

  The average number of failures for a single disk in the group is given by

  
  MTTR/(MTTF_Disk/Number_of_disks_remaining_in_the_group)
  

  The authors show that these facts leads to the following calculation of the MTTF for a RAID array:

  
  MTTF_RAID = (MTTF_Disk)2/((D+C*nG)*(G+C-1)*MTTR)
  

RAID Level 1

• RAID Level 1 is usually referred to a Disk Mirroring. with this RAID technique, the size of a datum is 1 bit and the parity is even. Thus, for each 1 bit, we maintain a 1 parity bit and for each 0 bit, we maintain a 0 parity bit, that is, we maintain a copy of every bit.
• Clearly with this RAID level, the number of check disks is the same as the number of data disks.

RAID Level 2

• RAID Level 2 uses the same idea as an error correcting code (ECC) memory device employs for single error correcting, dual error detecting (SECDED) error recovery.
• SECDED Memory typically uses Hamming Codes to do its job. A Hamming code requires adding ceiling(log₂(b)) bits to each datum of size b.
• Conceptually, these bits are interspersed into the data at bit positions 1, 2, 4, 8, and so forth. Bit n in this sequence stores the parity of every n bits starting at every other nth position starting at the check bit's position.

  What does that mean?

  Bit 1 stores parity for bits 1, 3, 5, 7, etc.
  Bit 2 stores parity for bits 2, 3 and 6, 7, and 10, 11, etc.
  Bit 4 stores parity for bits 4, 5, 6, 7, and 12, 13, 14, 15, etc.

• Note that the redundant parity is stored for the data bits in this scheme. (Parity for 3 is stored in bits 1 and 2, parity for 5 is stored in bits 1 and 4, parity for 6 is stored in bits 2 and 4, parity for 7 is stored in bits 1, 2, and 4.) Because of this, a single error can be corrected. Its location can be found by adding together the positions of the incorrect parity bits. A double error can be detected if a single 0 parity bit, calculating parity for all the rest of the bits is stored. If it is correct when any of the other bits is incorrect, there is a double error. If it is incorrect when not other bits are incorrect, it is a single bit in error.

  It three or more errors occur in this situation, the problem will be incorectly diagnosed.

• Now that you've been told more about Hamming codes than you wanted to hear, let it suffice to say that RAID Level 2 represents each bit of data on a separate disk, maintaining Hamming code bits on check disks.

• By the way, nobody really uses RAID Level 2, primarily because disks don't typically fail at the bit level. They already use ECCs of their own. Thus, the ECC of the RAID device is really redundant.

RAID Level 3

• RAID Level 3 uses a more appropriate mechanism for exploiting the ECC that's already built into the disks and their controllers. Most of the Hamming Code work of RAID Level goes into determining which disk failed. In a practical system, we'll know when a disk fails. We only need to repair the data on that disk. Such repair can be effected if we store a single parity disk and then calculate the contents of the replaced disk by repairing the parity of the group.

• That's exactly what RAID Level 3 does: Store datum in parallel on G disks and store a single check bit per datum.

RAID Level 4

• While RAID Levels 2 and 3 may be able to get excellent throughput on a single transfer (because they always get data from all data disks at the same time), they essenially require us to have syncrhonized disks and to perform only a single I/O operation at any given time.
• RAID Level 4 addresses these problems by storing the parity at a block level. Blocks of data are stored on G data disks and a parity block is stored on a single check disk.

RAID Level 5

• Level 4 requires that the parity disk be involved in every write operation. RAID Level 5 addresses this problem by distributing the Parity blocks among all the disks in the group.