RAID, fellesbetegnelse på metoder for samkjøring av datalagringsenheter for å oppnå økt ytelse eller feiltoleranse eller begge deler. RAID-algoritmene ble utviklet for magnetisk disk, men metodene er generelt anvendbare for alle lagertyper. RAID er en forkortelse for Redundant Arrays of Inexpensive Disks.

RAID lagrer tilhørende data på flere disker. Samlet lesekapasitet i forhold til lagring på én disk vil alltid bli større. Mønstre med redundant lagring gir høyere lagringssikkerhet mot tap av data enn lagring på én disk. Skriving tar lengre tid fordi data må skrives på to disker, eventuelt etter først å ha lest blokken som skrives over. Mer skrivearbeid er som regel lett å akseptere fordi data vanligvis leses mange fler ganger enn de oppdateres eller skrives. Et RAID-system av flere disker brukes som én disk, og det er koplet til brukermaskinen som en vanlig disk. 

Antall disker i en RAID-gruppe er \( n \). Data på hver disk er organisert i like store blokker. En blokk er et antall byte som skrives eller leses i en operasjon. Størrelsen på en blokk er normalt en potens av 2, for eksempel \(2^{12}=4096\) byte. Data kan plasseres på diskene i forskjellige mønstre eller system. Egenskapene blir forskjellig etter hvilket mønster som velges.  

Blokker i samme fil skrives fortløpende på diskene i gruppen; blokk 0 på disk 0, blokk 1 på disk 1, ... , blokk \(n \)på disk \( n \), blokk \(n+1\) på disk 0, osv. Samlet lese- og skrivehastighet blir større. Lagringssikkerheten blir mindre; det er større sannsynlighet for at én av \(n\)disker feiler enn at én disk alene feiler.

\( \begin{array}{|r|c|c|c|c|c|}   \hline  \texttt{Disker} & \texttt{D}0 &\texttt{D}1 & \texttt{D}2 & \texttt{D}3 & \texttt{D}4   \\ \hline \texttt{Stripe nr.}0&0&1&2&3&4 \\ \hline 1&5&6&7&8&9 \\ \hline 2&10&11&12&13&14 \\ \hline {\cdots }&&&&&  \\ \hline \end{array} \)

Blokkene i en stripe har samme blokkadresse på sin disk. Tallene i kolonnene under hver disk angir logisk blokknummer i den lagrede filen.

Data skrives på to disker eller diskgrupper. RAID 1 kalles også speiling av data. Skrivebelastningen blir dobbelt så stor ved at to disker skal skrives, men tiden det tar øker ikke mye fordi diskene skrives samtidig i parallell. Hvis en disk faller ut er data tilgjengelig på den andre, men den ødelagte disken må erstattes med en ny disk, og data må kopieres over fra den operative kopidisken. Tiden fra feil oppstår til en ny kopi er operativ kalles et sårbarhetsvindu. Data vil gå tapt hvis den gjenværende kopien også får feil før den ny kopidisken er etablert. RAID 1 krever dobbel lagringsplass. 

Hver byte splittes i 8 bit som skrives til hver sin disk. I tillegg beregnes 3 bit for feildetektering og korreksjon som også skrives til sine respektive 3 disker. Dette er en kopi av hvordan arbeidslager er bygget opp, og er ikke en praktisk måte for å lagre data på masselager, les disk. 

En blokk blir fordelt over \(n-1\) disker, en disk lagrer et helt antall sektorer (delblokker) som inngår i blokken. Delblokkene er like store. Den siste disken, disk \(n-1\), inneholder paritetsdata for de foranstående delblokkene. Paritetsdelblokken beregnes slik: \( b_p = b_0 \oplus b_1 \oplus \cdots \oplus b_{n-2} \). Paritetsdelblokken gjør det mulig å gjenskape en ødelagt delblokk ved å gjøre XOR (symbol: \( \oplus \)) på de gjenværende delblokkene i samme blokk.

Skriving tar lengre tid enn sammenlignet med skriving til en disk. Alle delblokkene må være skrevet for at blokken skal være ferdigskrevet og da må en vente til siste delblokk er skrevet.

Lesing tar på same måte lengre tid enn om blokken var på en disk, en må vente til siste delblokk er lest.

Når en disk faller ut må en skrive en erstatningsdisk. Data som skal skrives fås ved å lese de gjenværende disker og XOR-e innholdet.

Lagringsbehovet er \( 1+1/(n -1)\) del av nettovolumet.

Raid 4 deler ikke opp blokka. I stedet lagres blokkene forløpende innen hver stripe som i RAID 0, men forskjellen er at siste disken i stripen inneholder paritetsdata for blokkene foran i stripen. 

\( \begin{array}{|r|c|c|c|c|c|}   \hline  & \texttt{D}0 &  \texttt{D}1 & \texttt{D}2 & \texttt{D}3 & \texttt{DP}   \\  \hline  \texttt{Stripe nr.}0&0&1&2&3&P \\ \hline 1&4&5&6&7&P \\ \hline 2&8&9&10&11&P \\ \hline {\cdots } &&&&& \\ \hline \end{array} \)

RAID 4 er effektiv for lesing, men skriving blir noe mer omstendelig. For å beregne nytt innhold i paritetsblokken må en først fjerne paritetsbidraget fra gammelt innhold i blokken, deretter må en legge til bidraget fra det nye innholdet. Prosessen med å skrive nytt innhold i en blokk blir:

\( \begin{array}{l @\texttt{    } l} \texttt{les } (b_{gammel})& \\ \texttt{les } (P) & \\ P = P \oplus b_{gammel}  \oplus b_{ny} & \\ \texttt{skriv } (P)& \\  \texttt{skriv } (b_{ny}) & \\ \end {array}  \)

Begge berørte blokker må både leses og skrives. 

Hvis en disk faller ut kan innholdet på den gjenskapes ved å XOR-e de gjenværende diskene, stripe for stripe. 

Ved mye oppdatering vil paritetsdisken bli overbelastet, den må leses og skrives for hver oppdatering av de andre blokkene i samme stripe. I perioder med bare lesing blir ikke paritetsdisken brukt, forutsatt at alle disker er intakte. Det neste RAID-mønsteret gir jevnere belastning.

RAID 5 fungere som RAID 4 med den forskjell at paritetsblokkene er fordelt over alle diskene. Dermed får også alle diskene den samme belastningen under normale driftsforhold. Et mønster for å spre paritetsblokkene kan se slik ut: 

\( \begin{array}{|r|c|c|c|c|c|}  \hline  & \texttt{D}0 &\texttt{D}1 & \texttt{D}2 & \texttt{D}3 & \texttt{D}4   \\  \hline  \texttt{Stripe nr.} 0&\mathbf{P}&0&1&2&3 \\ \hline 1&4&\mathbf{P}&5&6&7 \\ \hline 2&8&9&\mathbf{P}&10&11 \\ \hline 3&12&13&14&\mathbf{P}&15 \\ \hline 4&16&17&18&19&\mathbf{P} \\ \hline 5&\mathbf{P}&20&21&22&23 \\ \hline \end{array} \)

I praksis er speiling (RAID 1) og RAID 5 mest brukt. For å redusere lengden på sårbarhetsvinduet kan en ha en montert, men ubrukt disk i RAID-kabinettet. Ved diskfeil kan systemet umiddelbart starte rekonstruksjon av innholdet på den ubrukbare disken og skrive det på den ubrukte disken.  

I figuren nedenfor har vi beregnet pariteten for data i fire blokker: D0 til D3. Resultatet er vist i den femte blokken: DP. En kan slette innholdet i en vilkårlig blokk og det kan gjenskapes ved å XOR-e innholdet av de fire gjenstående blokkene. Prøv selv.  

\(\begin{array}{ccccc cccc} \texttt{D0}& \oplus& \texttt{D1}& \oplus& \texttt{D2}& \oplus & \texttt{D3}& = & \texttt{DP}\\ {\begin{array}{|c|} \hline 1\\1\\0\\0\\1 \\ \hline \end{array}}& \oplus & {\begin{array}{|c|} \hline 1\\0\\0\\1\\1 \\ \hline \end{array}}& \oplus & {\begin{array}{|c|} \hline 1\\1\\0\\0\\0 \\ \hline \end{array}}& \oplus & {\begin{array}{|c|} \hline 1\\1\\1\\0\\0 \\ \hline \end{array}}& = & {\begin{array}{|c|} \hline 0\\1\\1\\1\\0 \\ \hline \end{array}}\end{array}\)

  • David A. Patterson, Garth Gibson, og Randy H. Katz. «A Case for Redundant Arrays of Inexpensive Disks (RAID)» i H. Boral og P. Larson (red). Proc. 1988 ACM SIGMOD Intl. Conf. on Management of Data (SIGMOD '88), New York: The Association for Computing Machinery, Inc., 1988, side 109-116.

Foreslå endringer i tekst

Foreslå bilder til artikkelen

Kommentarer

Har du spørsmål om artikkelen? Skriv her, så får du svar fra fagansvarlig eller redaktør.

Du må være logget inn for å kommentere.