Praktische RAID-prestaties

Het kiezen van een RAID-niveau is een oefening in het afwegen van vele factoren, waaronder kosten, betrouwbaarheid, capaciteit en, uiteraard, prestaties. RAID-prestaties kunnen moeilijk te begrijpen zijn, vooral omdat verschillende RAID-niveaus verschillende technieken gebruiken en zich in sommige gevallen nogal verschillend van elkaar gedragen. In dit artikel wil ik de gangbare RAID-niveaus RAID 0, 5, 6 en 10 verkennen om te zien hoe de prestaties tussen hen verschillen.

Voor de doeleinden van dit artikel zal RAID 1 worden beschouwd als een subset van RAID 10. Dit is vaak een handige manier om RAID 1 te beschouwen – als simpelweg een RAID 10-array met slechts één gespiegeld paar als lid. Aangezien RAID 1 werkelijk een RAID 10 met één enkel paar is en zich als zodanig gedraagt, werkt dit voortreffelijk om RAID-prestaties eenvoudig te begrijpen te maken, omdat het simpelweg overeenkomt met de RAID 10-prestatiecurve.

Er zijn twee typen prestaties om naar te kijken bij alle opslag: lezen en schrijven. Wat RAID betreft, is lezen uiterst eenvoudig en schrijven tamelijk complex. De leesprestaties zijn in de praktijk stabiel over alle RAID-typen. Schrijven daarentegen niet.

Om het bespreken van prestaties eenvoudiger te maken, moeten wij enkele termen definiëren, aangezien wij met enkele vergelijkingen zullen werken. In onze besprekingen zullen wij N gebruiken om het totale aantal schijven, vaak aangeduid als spindels, in onze array te vertegenwoordigen, en wij zullen X gebruiken om te verwijzen naar de prestaties van elke schijf afzonderlijk. Dit stelt ons in staat om te spreken in termen van relatieve prestaties als een factor van de schijfprestaties, waardoor wij de RAID-array kunnen abstraheren en niet in termen van ruwe IOPS hoeven te denken. Dit is belangrijk, aangezien IOPS vaak zeer moeilijk te definiëren zijn, maar wij prestaties op een zinvolle wijze kunnen vergelijken door erover te spreken in relatie tot de individuele schijven binnen de array.

Het is tevens belangrijk om te onthouden dat wij het alleen hebben over de prestaties van de RAID-array zelf, niet over een volledig opslagsubsysteem. Artefacten zoals geheugencaches en solid state-caches zullen verbluffende dingen doen om de algehele prestaties van een opslagsubsysteem te veranderen, maar veranderen niet fundamenteel de prestaties van de RAID-array zelf onder de motorkap. Er bestaat geen eenvoudige formule om te bepalen hoe verschillende cache-opties de algehele prestaties zullen beïnvloeden, maar het volstaat te zeggen dat het zeer dramatisch kan zijn, maar dit hangt sterk af, niet alleen van de cachekeuzes zelf, maar ook sterk van de werklast. Zelfs de grootste, snelste, meest robuuste cache-opties kunnen de langetermijn-, aanhoudende prestaties van een array niet veranderen.

RAID is complex en vele factoren beïnvloeden de uiteindelijke prestaties. Een daarvan is de implementatie van het RAID-systeem zelf. Een slechte implementatie zou latentie kunnen veroorzaken of zou kunnen nalaten gebruik te maken van de beschikbare spindels (zoals een RAID 1-array die slechts van één schijf leest in plaats van van beide tegelijk!). Er bestaat geen eenvoudige manier om rekening te houden met tekortkomingen in specifieke RAID-implementaties, dus wij moeten aannemen dat alle werken tot aan de grenzen van de specificatie, zoals inderdaad elk RAID-systeem voor ondernemingen zal doen. Het zijn voornamelijk hobby- en consumenten-RAID-systemen die dit nalaten te doen.

Sommige typen RAID hebben tevens dramatische hoeveelheden rekenkundige overhead die ermee gepaard gaan, terwijl andere dat niet hebben. Voornamelijk pariteits-RAID-niveaus vereisen zware verwerking om schrijfbewerkingen af te handelen, waarbij verschillende niveaus verschillende hoeveelheden berekening nodig hebben voor elke bewerking. Dit introduceert latentie, maar beperkt de doorvoer niet. Deze latentie zal echter variëren, gebaseerd op de implementatie van het RAID-niveau alsook op de verwerkingscapaciteit van het systeem in kwestie. Hardware-RAID zal iets gebruiken als een algemene CPU (vaak een Power- of ARM RISC-processor) of een op maat gemaakte ASIC om dit af te handelen, terwijl software-RAID dit overdraagt aan de eigen CPU van de server. Vaak is de server-CPU hier in feite sneller, maar verbruikt deze systeembronnen. ASIC's kunnen zeer snel zijn, maar zijn duur om te produceren. Deze latentie beïnvloedt de opslagprestaties, maar is zeer moeilijk te voorspellen en kan variëren van nominaal tot dramatisch. Daarom zal ik bij elk RAID-niveau de relatieve latentie-impact vermelden, maar zal ik niet proberen deze te meten. In de meeste RAID-prestatieberekeningen wordt deze latentie genegeerd, maar het is belangrijk om te begrijpen dat zij aanwezig is en, afhankelijk van de configuratie van de array, een merkbare impact op een werklast zou kunnen hebben.

Er is, het dient vermeld te worden, een minuscule prestatie-impact op leesbewerkingen als gevolg van efficiëntie in de indeling van gegevens op de schijf zelf. Pariteits-RAID vereist dat er gegevens op de schijven staan die nutteloos zijn tijdens een gezonde leesbewerking, maar niet gebruikt kunnen worden om deze te versnellen. Dit resulteert er feitelijk in dat het iets langzamer is. Maar deze impact is belachelijk klein en wordt normaliter niet gemeten en kan dus genegeerd worden.

Factoren zoals stripe-grootte beïnvloeden uiteraard eveneens de prestaties, maar aangezien dat configureerbaar is en geen intrinsiek artefact in enig RAID-niveau, zal ik dit hier negeren. Het is geen factor bij het kiezen van een RAID-niveau zelf, maar alleen bij het configureren van een niveau zodra het is gekozen.

De laatste factor die ik wil vermelden, is de lees-schrijfverhouding van opslagbewerkingen. Sommige RAID-arrays zullen vrijwel uitsluitend voor leesbewerkingen worden gebruikt, sommige vrijwel uitsluitend voor schrijfbewerkingen, maar de meeste gebruiken een mengsel van de twee, waarschijnlijk zoiets als tachtig procent lezen en twintig procent schrijven. Deze verhouding is zeer belangrijk om de prestaties te begrijpen die u uit uw specifieke RAID-array zult halen en om te begrijpen hoe elk RAID-niveau u zal beïnvloeden. Ik verwijs hiernaar als de lees-schrijfmix.

Wij meten opslagprestaties voornamelijk in IOPS. IOPS staat voor Input/Output Operations Per Second (ja, ik weet dat de letters niet goed op elkaar aansluiten, het is wat het is). Ik gebruik daarnaast de termen RIOPS voor Read IOPS, WIOPS voor Write IOPS en BIOPS voor Blended IOPS, die zouden komen met een verhouding van 80/20 of wat dan ook. Veel mensen spreken over opslagprestaties met één enkel IOPS-getal. Wanneer dit wordt gedaan, bedoelen zij normaliter Blended IOPS bij 50/50. Echter, zelden draait enige werklast op 50/50, dus dat getal kan uiterst misleidend zijn. Twee getallen, RIOPS en WIOPS, is wat nodig is om prestaties te begrijpen, en deze twee samen kunnen gebruikt worden om elke benodigde IOPS-mix te vinden. Een 50/50-mix is bijvoorbeeld zo eenvoudig als (RIOPS * .5) + (WIOPS * .5). De meer gangbare 80/20-mix zou zijn (RIOPS * .8) + (WIOPS * .2).

Nu wij enkele criteria en achtergrondkennis hebben vastgesteld, zullen wij ons verdiepen in onze RAID-niveaus zelf en zien hoe de prestaties daartussen variëren.

Voor alle RAID-niveaus wordt het Read IOPS-getal berekend met behulp van NX. Dit houdt uiteraard geen rekening met de nominale overhead-getallen die ik hierboven vermeld. Dit is een “beste geval”-getal, maar het werkelijke getal ligt er zo dicht bij dat het zeer praktisch is om simpelweg deze formule te gebruiken. Aangezien wij het aantal spindels (N) nemen en vermenigvuldigen met de IOPS-prestaties van een individuele schijf (X). Houd in gedachten dat schijven vaak verschillende lees- en schrijfprestaties hebben, dus zorg ervoor dat u de Read IOPS-classificatie of geteste snelheid van de schijf gebruikt voor de Read IOPS-berekening en de Write IOPS-classificatie of geteste snelheid voor de Write IOPS-berekening.

RAID 0

RAID 0 is het eenvoudigste RAID-niveau om te begrijpen, omdat er in de praktijk geen overhead is om u zorgen over te maken, geen bronnen worden verbruikt om het aan te drijven en zowel lezen als schrijven het volledige voordeel van elke spindel genieten, te allen tijde. Dus voor RAID 0 is onze formule voor schrijfprestaties zeer eenvoudig: NX. RAID 0 is altijd het best presterende RAID-niveau.

Een voorbeeld zou een RAID 0-array met acht spindels zijn. Als een individuele schijf in de array 125 IOPS levert, dan zou onze berekening uitgaan van N = 8 en X = 125, dus 8 * 125, wat 1.000 IOPS oplevert. Aangezien zowel de read- als de write-IOPS hier gelijk zijn, is het uiterst eenvoudig, aangezien wij 1K RIOPS, 1K WIOPS en 1K met elke mix daarvan krijgen. Zeer eenvoudig. Als wij de absolute IOPS van een individuele spindel niet zouden kennen, zouden wij naar een RAID 0-array met acht spindels kunnen verwijzen als leverend 8X Blended IOPS.

RAID 10

RAID 10 heeft het op een na eenvoudigste RAID-niveau om te berekenen. Omdat RAID 10 een RAID 0-stripe van mirror-sets is, hebben wij geen overhead om ons zorgen over te maken vanuit de stripe, maar moet elke mirror dezelfde gegevens tweemaal schrijven om de spiegeling tot stand te brengen. Dit halveert onze schrijfprestaties in vergelijking met een RAID 0-array met hetzelfde aantal schijven. Dit geeft ons een formule voor schrijfprestaties van simpelweg: NX/2 of .5NX.

Het dient opgemerkt te worden dat RAID 10 bij dezelfde capaciteit, in plaats van bij hetzelfde aantal spindels, dezelfde schrijfprestaties heeft als RAID 0, maar het dubbele aan leesprestaties – simpelweg omdat het tweemaal zoveel spindels vereist om dezelfde capaciteit te evenaren.

Dus een RAID 10-array met acht spindels zou N = 8 en X = 125 zijn, en onze resulterende berekening komt uit op (8 * 125)/2, wat 500 WIOPS of 4X WIOPS is. Een 50/50-mix zou resulteren in 750 Blended IOPS (1.000 Read IOPS en 500 Write IOPS).

Deze formule is op gelijke wijze van toepassing op RAID 1, RAID 10, RAID 100 en RAID 01.

Ongebruikelijke opties zoals drievoudige spiegeling in RAID 10 zouden deze schrijfboete veranderen. RAID 10 met drievoudige spiegeling zou bijvoorbeeld NX/3 zijn.

RAID 5

Hoewel RAID 5 verouderd is en nooit in nieuwe arrays gebruikt zou moeten worden, neem ik het hier op omdat het een welbekend en veelgebruikt RAID-niveau is en de prestaties ervan begrepen dienen te worden. RAID 5 is het meest basale van de moderne pariteits-RAID-niveaus. RAID 2, 3 & 4 worden niet langer aangetroffen in productiesystemen, en daarom zullen wij hun prestaties hier niet onderzoeken. RAID 5, hoewel niet aanbevolen voor gebruik vandaag de dag, is de basis van andere moderne pariteits-RAID-niveaus en is daarom belangrijk om te begrijpen.

Pariteits-RAID voegt een enigszins gecompliceerde noodzaak toe om pariteit te verifiëren en opnieuw te schrijven bij elke schrijfbewerking die naar schijf gaat. Dit betekent dat een RAID 5-array de gegevens zal moeten lezen, de pariteit zal moeten lezen, de gegevens zal moeten schrijven en ten slotte de pariteit zal moeten schrijven. Vier bewerkingen voor elke effectieve ene. Dit geeft ons een schrijfboete op RAID 5 van vier. Dus de formule voor RAID 5-schrijfprestaties is NX/4.

Dus als wij het voorbeeld met acht spindels volgen, waarbij de write-IOPS van een individuele spindel 125 is, zouden wij de volgende berekening krijgen: (8 * 125)/4 of 2X Write IOPS, wat neerkomt op 250 WIOPS. In een 50/50-mix zou dit resulteren in 625 Blended IOPS.

RAID 6

RAID 6 is, na RAID 10, waarschijnlijk het meest gangbare en bruikbare RAID-niveau dat vandaag de dag in gebruik is. RAID 6 is echter gebaseerd op RAID 5 en heeft nog een niveau van pariteit. Dit maakt het dramatisch veiliger dan RAID 5, wat zeer belangrijk is, maar legt tevens een dramatische schrijfboete op, aangezien elke schrijfbewerking vereist dat de schijven de gegevens lezen, de eerste pariteit lezen, de tweede pariteit lezen, de gegevens schrijven, de eerste pariteit schrijven en dan ten slotte de tweede pariteit schrijven. Dit komt neer op een zesvoudige schrijfboete, wat tamelijk dramatisch is. Dus onze formule is NX/6.

Ons voorbeeld voortzettend krijgen wij (8 * 125)/6, wat neerkomt op ~167 Write IOPS of 1,33X. In ons 50/50-mixvoorbeeld is dit een prestatie van 583,5 Blended IOPS. Zoals u kunt zien, veroorzaken pariteitsschrijfbewerkingen een zeer snelle afname van de schrijfprestaties en een merkbare daling van de blended prestaties.

RAID 7 (ook bekend als RAID 5.3 of RAID 7.3)

RAID 7 is een enigszins niet-standaard RAID-niveau met drievoudige pariteit, gebaseerd op de bestaande enkelvoudige pariteit van RAID 5 en de bestaande dubbele pariteit van RAID 6. De enige huidige implementatie van RAID 7 is RAIDZ3 van ZFS. Omdat RAID 7 alle overhead van zowel RAID 5 als RAID 6 bevat, plus de aanvullende overhead van het derde pariteitscomponent, hebben wij een schrijfboete van een verbijsterende achtvoud. Dus onze formule voor het vinden van RAID 7-schrijfprestaties is NX/8.

In ons voorbeeld zou dit betekenen dat (8 * 125)/8 neerkomt op 125 Write IOPS of 1X. Dus met acht schijven in onze array zouden wij slechts de schrijfprestaties van één enkele, op zichzelf staande schijf krijgen. Dat is significante overhead. Onze blended 50/50 IOPS zou neerkomen op slechts 562,5.

Complexe RAID

Complexe RAID-niveaus of geneste RAID-niveaus zoals RAID 50, 60, 61, 16, enzovoort, kunnen worden gevonden met behulp van de bovenstaande informatie en door de RAID op te splitsen in zijn componenten en elk daarvan toe te passen met behulp van de hierboven verstrekte formules. Er bestaat geen eenvoudige formule voor deze niveaus, omdat zij wisselende configuraties hebben. Het is noodzakelijk om ze op te splitsen in hun componenten en de formules meerdere malen toe te passen.

RAID 60 met twaalf schijven, twee sets van zes schijven, waarbij elke schijf 150 IOPS is, zou gedaan worden met twee RAID 6's. Het zou de NX van RAID 0 zijn, waarbij N twee is (voor twee RAID 6-arrays) en de X de resulterende prestatie van elke RAID 6 is. Elke RAID 6-set zou (6 * 150)/6 zijn. Dus de volledige array zou 2((6 * 150)/6) zijn. Wat resulteert in 300 Write IOPS.

Hetzelfde voorbeeld als hierboven, maar geconfigureerd als RAID 61, een gespiegeld paar RAID 6-arrays, zou dezelfde prestatie per RAID 6-array zijn, maar toegepast op de RAID 1-formule, die NX/2 is (waarbij X de resulterende prestatie van elke RAID-array is). Dus de uiteindelijke formule zou 2((6 * 150)/6)/2 zijn, wat neerkomt op 150 Write IOPS uit twaalf schijven.

Prestaties als een factor van capaciteit

Wanneer wij RAID-prestatieformules opstellen, denken wij hieraan in termen van het aantal spindels, wat ongelooflijk verstandig is. Dit is zeer nuttig bij het bepalen van de prestaties van een voorgestelde array of zelfs een bestaande, waar meting niet mogelijk is, en stelt ons in staat om de relatieve prestaties tussen verschillende voorgestelde opties te vergelijken. Het is in deze termen dat wij universeel aan RAID-prestaties denken.

Dit is echter niet altijd een goede benadering, omdat wij doorgaans naar RAID kijken als een factor van capaciteit in plaats van van prestaties of aantal spindels. Het zou zeer zeldzaam, maar zeker mogelijk zijn, dat iemand een RAID 6-array met acht schijven zou overwegen versus een RAID 10-array met acht schijven. Zo nu en dan zal dit voorkomen vanwege een chassisbeperking of een andere, soortgelijke reden. Maar doorgaans worden RAID-arrays bekeken vanuit het standpunt van de totale arraycapaciteit (oftewel bruikbare capaciteit) in plaats van het aantal spindels, prestaties of enige andere factor. Het is daarom merkwaardig dat wij vervolgens zouden overschakelen naar het bekijken van RAID-prestaties als een functie van het aantal spindels.

Als wij ons standpunt veranderen en draaien om capaciteit als de gemeenschappelijke factor, terwijl wij nog steeds aannemen dat de capaciteit en prestaties van de individuele schijf (X) constant blijven tussen de vergelijkingsobjecten, dan komen wij uit op een volledig ander prestatielandschap. Door dit te doen zien wij bijvoorbeeld dat RAID 0 niet langer het best presterende RAID-niveau is en dat de leesprestaties dramatisch variëren in plaats van een constante te zijn.

Capaciteit is een grillig iets, maar wij kunnen het destilleren tot het aantal spindels dat nodig is om de gewenste capaciteit te bereiken. Dit maakt deze bespreking veel eenvoudiger. Dus onze eerste stap is het bepalen van ons benodigde aantal spindels voor de ruwe capaciteit. Als wij een capaciteit van 10TB nodig hebben en schijven van 1TB gebruiken, zouden wij bijvoorbeeld tien spindels nodig hebben. Of als wij 3,2TB nodig hebben en schijven van 600GB gebruiken, zouden wij zes spindels nodig hebben. Wij zullen, anders dan voorheen, naar ons aantal spindels verwijzen als R. Zoals voorheen worden de prestaties van de individuele schijf weergegeven als X. (R wordt hier gebruikt om aan te geven dat dit het aantal voor ruwe capaciteit is (Raw Capacity Count), in plaats van het totale aantal spindels (Number).)

RAID 0 blijft eenvoudig, de prestaties zijn nog steeds RX, aangezien er geen aanvullende schijven zijn. Zowel de read- als de write-IOPS zijn simpelweg NX.

RAID 10 heeft RX Write IOPS, maar 2RX Read IOPS. Dit is dramatisch. Plotseling, bij het bekijken van prestaties als een factor van stabiele capaciteit, ontdekken wij dat RAID 10 dubbele leesprestaties heeft ten opzichte van RAID 0!

RAID 5 wordt iets lastiger. Write IOPS zou worden uitgedrukt als ((R + 1) * X)/4. De Read IOPS worden uitgedrukt als ((R +1) * X).

RAID 6 volgt, zoals wij verwachten, het patroon dat RAID 5 voorspelt. Write IOPS voor RAID 6 zijn ((R + 2) * X)/6. En de Read IOPS worden uitgedrukt als ((R + 2) * X).

RAID 7 valt precies in de pas. RAID 7 Write IOPS zou ((R + 3) * X)/8 zijn. En de Read IOPS zijn ((R + 3) * X).

Dit gezichtspunt verandert de wijze waarop wij over prestaties denken, en wanneer wij puur naar leesprestaties kijken, wordt RAID 0 het langzaamste RAID-niveau in plaats van het snelste, en wordt RAID 10 het snelste voor zowel lezen als schrijven, ongeacht wat de waarden voor R en X zijn!

Als wij een praktijkvoorbeeld nemen van 10 schijven van 2TB om 20TB bruikbare capaciteit te bereiken, waarbij elke schijf 100 IOPS aan prestaties heeft, en wij een 50/50-mix aannemen, dan zouden de resulterende IOPS zijn: RAID 0 met 1.000 Blended IOPS, RAID 10 met 1.500 Blended IOPS (2.000 RIOPS / 1.000 WIOPS), RAID 5 met 687,5 Blended IOPS (1.100 RIOPS / 275 WIOPS), RAID 6 met 700 Blended IOPS (1.200 RIOPS / 200 WIOPS) en ten slotte RAID 7 met 731,25 Blended IOPS (1.300 RIOPS / 162,5 WIOPS). RAID 10 is hier een dramatische winnaar.

Latentie en systeemimpact bij software-RAID

Zoals ik eerder heb gesteld, hebben RAID 0 en RAID 10 in de praktijk geen systeemoverhead om in overweging te nemen. De spiegelingsbewerking vereist in wezen geen rekenkundige inspanning en is, voor alle praktische doeleinden, onmeetbaar klein. Pariteits-RAID heeft wél rekenkundige overhead, en dit resulteert in latentie op de opslaglaag en het verbruik van systeembronnen. Uiteraard, als wij hardware-RAID gebruiken, zijn die bronnen toegewijd aan de RAID-array en hebben zij geen andere functie dan in deze rol te worden verbruikt. Als wij echter software-RAID gebruiken, zijn dit algemene systeembronnen (voornamelijk CPU) die worden verbruikt ten behoeve van de verwerking van de RAID-array.

De impact op zelfs een zeer klein systeem met een grote hoeveelheid RAID is nog steeds zeer klein, maar kan worden gemeten en zou in overweging genomen moeten worden, al is het maar licht. Latentie en systeemimpact houden rechtstreeks verband met elkaar.

Er bestaat geen eenvoudige manier om latentie en systeemimpact voor verschillende RAID-niveaus aan te geven, behalve op deze wijze: RAID 0 en RAID 10 hebben in de praktijk geen latentie of impact, RAID 5 heeft enige latentie en impact, RAID 6 heeft ruwweg tweemaal zoveel rekenkundige latentie en impact als RAID 5, en RAID 7 heeft ruwweg het drievoudige aan rekenkundige latentie en impact als RAID 5.

In veel gevallen zullen deze latentie en systeemimpact zo klein zijn dat zij niet gemeten kunnen worden met standaard systeemtools, en naarmate moderne processoren steeds krachtiger worden, zullen de latentie en systeemimpact blijven afnemen. De impact is voor RAID 5- en RAID 6-systemen sinds ongeveer 2001 als verwaarloosbaar beschouwd, zelfs op low-end, commodity-hardware. Maar het is mogelijk dat er op zwaar belaste systemen met een grote hoeveelheid pariteits-RAID-activiteit conflict zou kunnen ontstaan tussen het RAID-subsysteem en andere processen die systeembronnen vereisen.

Referentie: The IT Hollow – Understanding the RAID Penalty

Artikel oorspronkelijk geplaatst op de StorageCraft Blog – RAID Performance.