Browse Prior Art Database

LRAID: Use of Log Disks for an Efficient RAID Design

IP.com Disclosure Number: IPCOM000111008D
Original Publication Date: 1994-Feb-01
Included in the Prior Art Database: 2005-Mar-26
Document File: 2 page(s) / 129K

Publishing Venue

IBM

Related People

Bhide, A: AUTHOR [+2]

Abstract

A method is disclosed that provides the same degree of reliability as RAID-5 [4] disk arrays with significantly fewer disk arms. RAID-5 is a disk array organization proposed in [4] to use an array of small disks to provide reliability comparable to mirrored disks, but at a much lower cost in terms of disk space. However, in On-Line Transaction Processing (OLTP) applications, the critical resource is typically not disk space but disk arms. [1,2] point out that many disk farms are 50 % empty to get good response time for disk I/Os. The cost of reliability in RAID-5 disk arrays is that one random write requires four disk I/Os. Thus, RAID level 5 performs poorly for a workload with a lot of random updates, such as the TPCA benchmark and other typical OLTP applications.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 43% of the total text.

LRAID:  Use of Log Disks for an Efficient RAID Design

      A method is disclosed that provides the same degree of
reliability as RAID-5 [4]  disk arrays with significantly fewer disk
arms.  RAID-5 is a disk array organization proposed in [4] to use an
array of small disks to provide reliability comparable to mirrored
disks, but at a much lower cost in terms of disk space.  However, in
On-Line Transaction Processing (OLTP) applications, the critical
resource is typically not disk space but disk arms.  [1,2] point out
that many disk farms are 50 % empty to get good response time for
disk I/Os.  The cost of reliability in RAID-5 disk arrays is that one
random write requires four disk I/Os.  Thus, RAID level 5 performs
poorly for a workload with a lot of random updates, such as the TPCA
benchmark and other typical OLTP applications.

      Disclosed is a RAID organization which reduces the number of
physical I/Os for each disk write.  In our scheme, the result of the
exclusive or (XOR) of the old data block with the new data block is
written on a log maintained on a separate log disk.  Since the log is
written in a sequential manner, each logical disk write causes one
random disk write and one sequential disk write.  Asynchronously, the
log on the check disk is garbage-collected and the check sums on a
separate check disk are updated.  In the case of disk failure, in our
scheme, the unprocessed log has to be processed first and the check
disk must be updated.  Then the RAID level 5 recovery algorithm can
be used.  The configuration that we consider consists of a RAID level
4 with group size of G (i.e., G data disks) and a check disk.  Our
scheme requires the addition of a log disk.

      In a standard RAID level 4 scheme, each write involves updating
the parity on the check disk.  This involves reading the old parity
page, and XORing the old data page, new data page and the old parity
page.  This involves two random I/Os and one more I/O to the same
track as one of the random I/Os.  The basic problem in this scheme is
that the check disk becomes overloaded due to the fact that all disk
writes involve updating the parity and therefore the check disk sees
G times as many I/Os for each update as any other data disk.  This
motivates RAID level 5 where the parity blocks are striped across all
the disks.  However, this configuration also involves multiple I/Os
per write, as described above.

      In our scheme, each logical write involves writing the data
block to disk and writing the XOR result of the old data block and
the new data block to the log disk.  The check disk contains possibly
out-of-date parity blocks for the corresponding blocks on the G data
disks.  Periodically, the data on the log disk is used to update the
check disk.  The basic advantage of this scheme is that the
read-modify-write of the parity on the check disk is postponed and is
done in a more efficiently using sequential I/Os instead of...