Wat is raid 1. RAID-schijfarrays: wat is het en waarom is het nodig? Welke methode om RAID te implementeren - software of hardware?

De verschuiving in de focus van processorgerichte naar datacentrische applicaties zorgt voor het toenemende belang van dataopslagsystemen. Tegelijkertijd is het probleem van de lage doorvoer en de fouttolerantie die kenmerkend zijn voor dergelijke systemen altijd heel belangrijk geweest en altijd een oplossing vereist.

In de moderne computerindustrie worden magnetische schijven veel gebruikt als secundair gegevensopslagsysteem, omdat ze, ondanks al hun tekortkomingen, de beste eigenschappen hebben voor het overeenkomstige type apparaat tegen een betaalbare prijs.

Kenmerken van de technologie voor het construeren van magnetische schijven hebben geleid tot een aanzienlijke discrepantie tussen de prestatieverbetering van processormodules en de magnetische schijven zelf. Als in 1990 de beste onder de seriële schijven 5,25″-schijven waren met een gemiddelde toegangstijd van 12 ms en een latentietijd van 5 ms (bij een spilsnelheid van ongeveer 5.000 rpm1), dan behoort de palm vandaag tot de 3,5″-schijven met een gemiddelde toegangstijd van 5 ms en vertragingstijd 1 ms (bij spiltoerental 10.000 rpm). Hier zien we een verbetering van de technische kenmerken van ongeveer 100%. Tegelijkertijd namen de processorprestaties met meer dan 2.000% toe. Dit is grotendeels mogelijk omdat de processors de directe voordelen hebben van het gebruik van VLSI (Very Large Scale Integration). Het gebruik ervan maakt het niet alleen mogelijk om de frequentie te verhogen, maar ook het aantal componenten dat in de chip kan worden geïntegreerd, wat het mogelijk maakt architectonische voordelen te introduceren die parallel computergebruik mogelijk maken.

1 - Gemiddelde gegevens.

De huidige situatie kan worden gekarakteriseerd als een I/O-crisis in het secundaire opslagsysteem.

Prestaties verhogen

De onmogelijkheid om de technologische parameters van magnetische schijven aanzienlijk te vergroten, brengt de noodzaak met zich mee om naar andere manieren te zoeken, waarvan er één parallelle verwerking is.

Als je een datablok over N schijven van een array rangschikt en deze plaatsing zo organiseert dat het mogelijk is om tegelijkertijd informatie te lezen, dan kan dit blok N keer sneller worden gelezen (zonder rekening te houden met de blokvormingstijd). Omdat alle gegevens parallel worden overgedragen, wordt deze architectonische oplossing genoemd parallelle toegangsarray(array met parallelle toegang).

Parallelle arrays worden doorgaans gebruikt voor toepassingen die grote gegevensoverdrachten vereisen.

Sommige taken worden daarentegen gekenmerkt door een groot aantal kleine verzoeken. Dergelijke taken omvatten bijvoorbeeld databaseverwerkingstaken. Door databaserecords over arrayschijven te verdelen, kunt u de belasting verdelen door de schijven onafhankelijk van elkaar te positioneren. Deze architectuur wordt meestal genoemd array met onafhankelijke toegang(array met onafhankelijke toegang).

Het vergroten van de fouttolerantie

Helaas neemt de betrouwbaarheid van de gehele array af naarmate het aantal schijven in een array toeneemt. Bij onafhankelijke storingen en een exponentiële verdelingswet van de tijd tussen storingen wordt de MTTF van de gehele array (gemiddelde tijd tot falen) berekend met behulp van de formule MTTF array = MMTF hdd /N hdd (MMTF hdd is de gemiddelde tijd tot falen van één schijf ; NHDD is de nummerschijven).

Er is dus behoefte aan het vergroten van de fouttolerantie van schijfarrays. Om de fouttolerantie van arrays te vergroten, wordt redundante codering gebruikt. Er zijn twee hoofdtypen codering die worden gebruikt in redundante schijfarrays: duplicatie en pariteit.

Duplicatie of spiegeling wordt het vaakst gebruikt in schijfarrays. Eenvoudige spiegelsystemen gebruiken twee kopieën van gegevens, waarbij elke kopie zich op afzonderlijke schijven bevindt. Dit schema is vrij eenvoudig en vereist geen extra hardwarekosten, maar het heeft één belangrijk nadeel: het gebruikt 50% van de schijfruimte om een ​​kopie van informatie op te slaan.

De tweede manier om redundante disk-arrays te implementeren is het gebruik van redundante codering met behulp van pariteitsberekening. Pariteit wordt berekend door alle tekens in het datawoord te XORen. Door pariteit te gebruiken in redundante schijfarrays wordt de overhead teruggebracht tot een waarde die wordt berekend met de formule: HP hdd =1/N hdd (HP hdd is overhead; N hdd is het aantal schijven in de array).

Geschiedenis en ontwikkeling van RAID

Ondanks het feit dat opslagsystemen op basis van magnetische schijven al veertig jaar worden geproduceerd, is de massaproductie van fouttolerante systemen pas onlangs begonnen. Redundante schijfarrays, gewoonlijk RAID genoemd (redundante arrays van goedkope schijven), werden in 1987 geïntroduceerd door onderzoekers (Petterson, Gibson en Katz) aan de Universiteit van Californië, Berkeley. Maar RAID-systemen werden pas wijdverspreid toen schijven die geschikt waren voor gebruik in redundante arrays beschikbaar en voldoende productief kwamen. Sinds het witboek over RAID uit 1988 is het onderzoek naar redundante disk-arrays explosief toegenomen in een poging een breed scala aan afwegingen te maken tussen kosten, prestaties en betrouwbaarheid.

Er was ooit een incident met de afkorting RAID. Feit is dat op het moment dat dit artikel werd geschreven, alle schijven die in pc's werden gebruikt, goedkope schijven werden genoemd, in tegenstelling tot dure schijven voor mainframes (mainframecomputers). Maar voor gebruik in RAID-arrays was het nodig om vrij dure apparatuur te gebruiken in vergelijking met andere pc-configuraties, dus begon RAID te worden ontcijferd als een redundante array van onafhankelijke schijven 2 - een redundante array van onafhankelijke schijven.

2 - Definitie van RAID-adviesraad

RAID 0 werd door de industrie geïntroduceerd als de definitie van een niet-fouttolerante disk-array. Berkeley definieerde RAID 1 als een gespiegelde schijfarray. RAID 2 is gereserveerd voor arrays die Hamming-code gebruiken. RAID-niveaus 3, 4 en 5 gebruiken pariteit om gegevens tegen afzonderlijke fouten te beschermen. Het waren deze niveaus, inclusief niveau 5, die in Berkeley werden gepresenteerd, en deze RAID-taxonomie werd als de facto standaard aangenomen.

RAID-niveaus 3,4,5 zijn behoorlijk populair en gebruiken een goede schijfruimte, maar ze hebben één belangrijk nadeel: ze zijn alleen bestand tegen enkele fouten. Dit geldt met name bij gebruik van een groot aantal schijven, wanneer de kans op gelijktijdige downtime van meer dan één apparaat toeneemt. Bovendien worden ze gekenmerkt door een lang herstel, wat ook enkele beperkingen oplegt aan het gebruik ervan.

Tegenwoordig is er een vrij groot aantal architecturen ontwikkeld die de werking van de array garanderen, zelfs bij gelijktijdig falen van twee willekeurige schijven, zonder gegevensverlies. Van de hele set is het de moeite waard om tweedimensionale pariteit en EVENODD op te merken, die pariteit gebruiken voor codering, en RAID 6, die gebruik maakt van Reed-Solomon-codering.

In een schema dat gebruik maakt van dual-space-pariteit, neemt elk datablok deel aan de constructie van twee onafhankelijke codewoorden. Als dus een tweede schijf in hetzelfde codewoord faalt, wordt een ander codewoord gebruikt om de gegevens te reconstrueren.

De minimale redundantie in een dergelijke array wordt bereikt met een gelijk aantal kolommen en rijen. En is gelijk aan: 2 x Vierkant (N Schijf) (in “vierkant”).

Als de array met twee spaties niet in een "vierkant" is georganiseerd, zal bij de implementatie van het bovenstaande schema de redundantie hoger zijn.

De EVODD-architectuur heeft een fouttolerantieschema dat lijkt op dual-space-pariteit, maar een andere plaatsing van informatieblokken die een minimaal redundant capaciteitsgebruik garandeert. Net als bij dual-space pariteit neemt elk datablok deel aan de constructie van twee onafhankelijke codewoorden, maar de woorden worden zo geplaatst dat de redundantiecoëfficiënt constant is (in tegenstelling tot het vorige schema) en gelijk is aan: 2 x Vierkant (N Schijf).

Door gebruik te maken van twee controletekens, pariteits- en niet-binaire codes, kan het datawoord worden ontworpen om fouttolerantie te bieden wanneer een dubbele fout optreedt. Dit ontwerp staat bekend als RAID 6. Niet-binaire code, gebaseerd op Reed-Solomon-codering, wordt doorgaans berekend met behulp van tabellen of als een iteratief proces met behulp van lineaire registers met gesloten lus, een relatief complexe operatie die gespecialiseerde hardware vereist.

Gezien het feit dat het gebruik van klassieke RAID-opties, die voor veel toepassingen voldoende fouttolerantie bieden, vaak onaanvaardbaar lage prestaties leveren, implementeren onderzoekers van tijd tot tijd verschillende maatregelen die de prestaties van RAID-systemen helpen verbeteren.

In 1996 stelden Savage en Wilks AFRAID voor: een frequent redundante reeks onafhankelijke schijven. Deze architectuur offert enigszins fouttolerantie op voor prestaties. In een poging om het kleine schrijfprobleem dat typisch is voor RAID-niveau 5-arrays te compenseren, is het mogelijk om striping gedurende een bepaalde periode zonder pariteitsberekening te laten. Als de schijf die is aangewezen voor pariteitsopname bezet is, wordt de pariteitsopname vertraagd. Het is theoretisch bewezen dat een vermindering van de fouttolerantie met 25% de prestaties met 97% kan verhogen. AFRAID verandert effectief het foutmodel van enkelvoudige fouttolerante arrays, omdat een codewoord dat geen bijgewerkte pariteit heeft, vatbaar is voor schijfstoringen.

In plaats van fouttolerantie op te offeren, kunt u traditionele prestatietechnieken gebruiken, zoals caching. Aangezien het schijfverkeer zeer druk is, kunt u een terugschrijfcache gebruiken om gegevens op te slaan wanneer de schijven bezet zijn. En als het cachegeheugen wordt gemaakt in de vorm van niet-vluchtig geheugen, worden de gegevens bij een stroomstoring opgeslagen. Bovendien maken uitgestelde schijfbewerkingen het mogelijk om willekeurig kleine blokken te combineren om efficiëntere schijfbewerkingen uit te voeren.

Er zijn ook veel architecturen die volume opofferen om de prestaties te verbeteren. Daartoe behoren vertraagde wijziging op de logschijf en verschillende schema's voor het wijzigen van de logische plaatsing van gegevens in de fysieke schijf, waardoor u de bewerkingen in de array efficiënter kunt verdelen.

Eén van de opties is pariteit loggen(pariteitsregistratie), waarbij het kleine schrijfprobleem wordt opgelost en het gebruik van schijven efficiënter wordt. Pariteitsregistratie stelt pariteitswijzigingen naar RAID 5 uit door ze vast te leggen in een FIFO-logboek, dat zich deels in het geheugen van de controller en deels op schijf bevindt. Gegeven dat toegang tot een volledige track gemiddeld tien keer efficiënter is dan toegang tot een sector, verzamelt pariteitsregistratie grote hoeveelheden gewijzigde pariteitsgegevens, die vervolgens samen worden geschreven naar een schijf die bestemd is voor het opslaan van pariteit over de hele track.

Architectuur zwevende gegevens en pariteit(zwevend en pariteit), waardoor de fysieke plaatsing van schijfblokken opnieuw kan worden toegewezen. Op elke cilinder worden vrije sectoren geplaatst om deze te verkleinen rotatie latentie(rotatievertragingen), gegevens en pariteit worden aan deze vrije ruimtes toegewezen. Om de werking tijdens een stroomstoring te garanderen, moeten de pariteit en de datamap in een niet-vluchtig geheugen worden opgeslagen. Als u de plaatsingskaart kwijtraakt, gaan alle gegevens in de array verloren.

Virtueel strippen- is een zwevende gegevens- en pariteitsarchitectuur die gebruikmaakt van terugschrijfcache. Natuurlijk besef je de positieve kanten van beide.

Daarnaast zijn er andere manieren om de prestaties te verbeteren, zoals RAID-bewerkingen. Ooit heeft Seagate ondersteuning voor RAID-bewerkingen ingebouwd in zijn schijven met Fibre Chanel- en SCSI-interfaces. Dit maakte het mogelijk om het verkeer tussen de centrale controller en de schijven in de array voor RAID 5-systemen te verminderen. Dit was een fundamentele innovatie op het gebied van RAID-implementaties, maar de technologie kreeg geen start in het leven, aangezien sommige features van Fiber zijn toegepast. Chanel- en SCSI-standaarden verzwakken het faalmodel voor disk-arrays.

Voor dezelfde RAID 5 werd de TickerTAIP-architectuur geïntroduceerd. Het ziet er zo uit: het centrale besturingsmechanisme, het oorspronkelijke knooppunt (initiatorknooppunt) ontvangt gebruikersverzoeken, selecteert een verwerkingsalgoritme en draagt ​​vervolgens schijfwerk en pariteit over aan het werkknooppunt (werkknooppunt). Elk werkknooppunt verwerkt een subset van de schijven in de array. Net als in het Seagate-model dragen werkknooppunten onderling gegevens over zonder de deelname van het initiërende knooppunt. Als een werkknooppunt uitvalt, zijn de schijven die het gebruikt niet meer beschikbaar. Maar als het codewoord zo is opgebouwd dat elk van zijn symbolen wordt verwerkt door een afzonderlijk werkknooppunt, herhaalt het fouttolerantieschema RAID 5. Om storingen van het initiërende knooppunt te voorkomen, wordt het gedupliceerd, waardoor we een architectuur krijgen die is bestand tegen storingen van een van zijn knooppunten. Ondanks al zijn positieve eigenschappen lijdt deze architectuur onder het ‘schrijfgat’-probleem. Dit betekent dat er een fout optreedt wanneer meerdere gebruikers tegelijkertijd het codewoord wijzigen en het knooppunt uitvalt.

We moeten ook een redelijk populaire methode noemen om RAID snel te herstellen - met behulp van een vrije schijf (reserve). Als een van de schijven in de array defect raakt, kan de RAID worden hersteld met een vrije schijf in plaats van de defecte schijf. Het belangrijkste kenmerk van deze implementatie is dat het systeem naar de vorige (fail-safe) toestand gaat zonder externe tussenkomst. Bij gebruik van een gedistribueerde spaararchitectuur worden de logische blokken van een reserveschijf fysiek verdeeld over alle schijven in de array, waardoor het niet meer nodig is om de array opnieuw op te bouwen als een schijf defect raakt.

Om het herstelprobleem dat typisch is voor klassieke RAID-niveaus te vermijden, werd een architectuur genoemd pariteitsdeclustering(pariteitsverdeling). Het gaat om het plaatsen van minder logische schijfeenheden met een grotere capaciteit op kleinere fysieke schijfeenheden met een grotere capaciteit. Met behulp van deze technologie wordt de responstijd van het systeem op een verzoek tijdens de reconstructie met meer dan de helft verbeterd en wordt de reconstructietijd aanzienlijk verkort.

Architectuur van basis RAID-niveaus

Laten we nu de architectuur van de basisniveaus van RAID in meer detail bekijken. Laten we, voordat we erover nadenken, een aantal aannames doen. Om de principes van het construeren van RAID-systemen te demonstreren, beschouwen we een set van N schijven (voor de eenvoud nemen we aan dat N een even getal is), die elk uit M blokken bestaan.

We zullen de data aanduiden - Dm,n, waarbij m het aantal datablokken is, n het aantal subblokken is waarin het datablok D is verdeeld.

Schijven kunnen verbinding maken met één of meerdere kanalen voor gegevensoverdracht. Het gebruik van meer kanalen vergroot de systeemcapaciteit.

RAID 0. Striped Disk Array zonder fouttolerantie

Het is een schijfarray waarin gegevens in blokken worden verdeeld en elk blok naar een afzonderlijke schijf wordt geschreven (of gelezen). Er kunnen dus meerdere I/O-bewerkingen tegelijkertijd worden uitgevoerd.

Voordelen:

• hoogste prestaties voor toepassingen die een intensieve verwerking van I/O-verzoeken en grote datavolumes vereisen;
• gemak van implementatie;
• lage kosten per volume-eenheid.

Gebreken:

• geen fouttolerante oplossing;
• Als één schijf uitvalt, gaan alle gegevens in de array verloren.

RAID 1. Redundante schijfarray of spiegeling

Mirroring is een traditionele manier om de betrouwbaarheid van een kleine disk-array te vergroten. In de eenvoudigste versie worden twee schijven gebruikt waarop dezelfde informatie wordt vastgelegd, en als een van deze uitvalt, blijft er een duplicaat van over, dat in dezelfde modus blijft werken.

Voordelen:

• gemak van implementatie;
• gemak van arrayherstel in geval van storing (kopiëren);
• voldoende hoge prestaties voor toepassingen met een hoge verzoekintensiteit.

Gebreken:

• hoge kosten per volume-eenheid - 100% redundantie;
• lage gegevensoverdrachtsnelheid.

RAID 2. Fouttolerante schijfarray met Hamming Code ECC.

De redundante codering die in RAID 2 wordt gebruikt, wordt Hamming-code genoemd. Met de Hamming-code kunt u enkele fouten corrigeren en dubbele fouten detecteren. Tegenwoordig wordt het actief gebruikt in de technologie voor het coderen van gegevens in RAM van het ECC-type. En het coderen van gegevens op magnetische schijven.

In dit geval wordt een voorbeeld getoond met een vast aantal schijven vanwege de omslachtigheid van de beschrijving (een datawoord bestaat respectievelijk uit 4 bits, de ECC-code is 3).

Voordelen:

• snelle foutcorrectie (“on the fly”);
• zeer hoge gegevensoverdrachtsnelheid voor grote volumes;
• naarmate het aantal schijven toeneemt, nemen de overheadkosten af;
• vrij eenvoudige uitvoering.

Gebreken:

• hoge kosten met een klein aantal schijven;
• lage verwerkingssnelheid van verzoeken (niet geschikt voor transactiegerichte systemen).

RAID 3. Fouttolerante array met parallelle gegevensoverdracht en pariteit (Parallel Transfer Disks with Parity)

Gegevens worden op byteniveau opgesplitst in subblokken en gelijktijdig naar alle schijven in de array geschreven, behalve één, die wordt gebruikt voor pariteit. Het gebruik van RAID 3 lost het probleem van de hoge redundantie in RAID 2 op. De meeste besturingsschijven die in RAID-niveau 2 worden gebruikt, zijn nodig om de positie van de defecte bit te bepalen. Maar dit is niet nodig, omdat de meeste controllers kunnen bepalen wanneer een schijf defect is met behulp van speciale signalen of aanvullende codering van informatie die naar de schijf wordt geschreven en wordt gebruikt om willekeurige fouten te corrigeren.

Voordelen:

• zeer hoge gegevensoverdrachtsnelheid;
• schijfstoringen hebben weinig invloed op de snelheid van de array;

Gebreken:

• moeilijke implementatie;
• lage prestaties met hoge intensiteitsverzoeken voor kleine gegevens.

RAID 4. Fouttolerante reeks onafhankelijke schijven met gedeelde pariteitsschijf (onafhankelijke gegevensschijven met gedeelde pariteitsschijf)

Gegevens worden op blokniveau uitgesplitst. Elk gegevensblok wordt naar een afzonderlijke schijf geschreven en kan afzonderlijk worden gelezen. Pariteit voor een groep blokken wordt gegenereerd bij schrijven en gecontroleerd bij lezen. RAID Level 4 verbetert de prestaties van kleine gegevensoverdrachten door middel van parallellisme, waardoor meer dan één I/O-toegang tegelijkertijd kan worden uitgevoerd. Het belangrijkste verschil tussen RAID 3 en 4 is dat bij de laatste de datastriping wordt uitgevoerd op sectorniveau, in plaats van op bit- of byteniveau.

Voordelen:

• zeer hoge leessnelheid van grote hoeveelheden gegevens;
• hoge prestaties bij hoge intensiteit van gegevensleesverzoeken;
• lage overhead om redundantie te implementeren.

Gebreken:

• zeer lage prestaties bij het schrijven van gegevens;
• lage leessnelheid van kleine gegevens met enkele verzoeken;
• asymmetrie van prestaties met betrekking tot lezen en schrijven.

RAID 5. Fouttolerante reeks onafhankelijke schijven met gedistribueerde pariteit (onafhankelijke gegevensschijven met gedistribueerde pariteitsblokken)

Dit niveau is vergelijkbaar met RAID 4, maar in tegenstelling tot het vorige wordt de pariteit cyclisch verdeeld over alle schijven in de array. Deze wijziging verbetert de prestaties bij het schrijven van kleine hoeveelheden gegevens op multitasking-systemen. Als schrijfbewerkingen goed zijn gepland, is het mogelijk om maximaal N/2 blokken parallel te verwerken, waarbij N het aantal schijven in de groep is.

Voordelen:

• hoge gegevensregistratiesnelheid;
• redelijk hoge leessnelheid van gegevens;
• hoge prestaties bij hoge intensiteit van gegevenslees-/schrijfverzoeken;
• lage overhead om redundantie te implementeren.

Gebreken:

• De leessnelheid van gegevens is lager dan in RAID 4;
• lage lees-/schrijfsnelheid van kleine gegevens met enkele verzoeken;
• vrij complexe implementatie;
• complex gegevensherstel.

RAID 6. Fouttolerante reeks onafhankelijke schijven met twee onafhankelijke gedistribueerde pariteitsschema's (onafhankelijke gegevensschijven met twee onafhankelijke gedistribueerde pariteitsschema's)

Gegevens worden gepartitioneerd op blokniveau, vergelijkbaar met RAID 5, maar naast de vorige architectuur wordt een tweede schema gebruikt om de fouttolerantie te verbeteren. Deze architectuur is dubbelfouttolerant. Bij het uitvoeren van een logische schrijfbewerking zijn er echter in feite zes schijftoegangen, waardoor de verwerkingstijd van één verzoek aanzienlijk wordt verlengd.

Voordelen:

• hoge fouttolerantie;
• redelijk hoge snelheid van verzoekverwerking;
• relatief lage overhead om redundantie te implementeren.

Gebreken:

• zeer complexe implementatie;
• complex gegevensherstel;
• zeer lage schrijfsnelheid van gegevens.

Met moderne RAID-controllers kunt u verschillende RAID-niveaus combineren. Op deze manier is het mogelijk om systemen te implementeren die de voordelen van verschillende niveaus combineren, evenals systemen met een groot aantal schijven. Meestal is dit een combinatie van niveau nul (strippen) en een soort fouttolerant niveau.

RAID 10. Fouttolerante array met duplicatie en parallelle verwerking

Deze architectuur is een RAID 0-array waarvan de segmenten RAID 1-arrays zijn. Het combineert zeer hoge fouttolerantie en prestaties.

Voordelen:

• hoge fouttolerantie;
• hoge prestaties.

Gebreken:

• zeer hoge kosten;
• beperkte schaalvergroting.

RAID 30. Fouttolerante array met parallelle gegevensoverdracht en betere prestaties.

Het is een RAID 0-array, waarvan de segmenten RAID 3-arrays zijn. Het combineert fouttolerantie en hoge prestaties. Meestal gebruikt voor toepassingen die grote hoeveelheden seriële gegevensoverdracht vereisen.

Voordelen:

• hoge fouttolerantie;
• hoge prestaties.

Gebreken:

• hoge kosten;
• beperkte schaalvergroting.

RAID 50: fouttolerante array met gedistribueerde pariteit en betere prestaties

Het is een RAID 0-array, waarvan de segmenten RAID 5-arrays zijn. Het combineert fouttolerantie en hoge prestaties voor toepassingen met een hoge verzoekintensiteit en hoge gegevensoverdrachtsnelheden.

Voordelen:

• hoge fouttolerantie;
• hoge gegevensoverdrachtsnelheid;
• hoge snelheid van aanvraagverwerking.

Gebreken:

• hoge kosten;
• beperkte schaalvergroting.

RAID 7: Fouttolerante array geoptimaliseerd voor prestaties. (Geoptimaliseerde asynchronie voor hoge I/O-snelheden en hoge gegevensoverdrachtsnelheden). RAID 7® is een geregistreerd handelsmerk van Storage Computer Corporation (SCC)

Laten we, om de RAID 7-architectuur te begrijpen, eens kijken naar de kenmerken ervan:

1. Alle verzoeken om gegevensoverdracht worden asynchroon en onafhankelijk verwerkt.
2. Alle lees-/schrijfbewerkingen worden in de cache opgeslagen via de snelle x-bus.
3. De pariteitsschijf kan op elk kanaal worden geplaatst.
4. De microprocessor van de arraycontroller maakt gebruik van een real-time besturingssysteem dat zich richt op verwerkingsprocessen.
5. Het systeem heeft een goede schaalbaarheid: tot 12 hostinterfaces en tot 48 schijven.
6. Het besturingssysteem bestuurt de communicatiekanalen.
7. Er wordt gebruik gemaakt van standaard SCSI-schijven, bussen, moederborden en geheugenmodules.
8. Er wordt gebruik gemaakt van een snelle X-bus om met intern cachegeheugen te werken.
9. De procedure voor het genereren van pariteit is geïntegreerd in de cache.
10. Schijven die aan het systeem zijn gekoppeld, kunnen als afzonderlijk worden gedeclareerd.
11. Voor het beheren en monitoren van het systeem kan een SNMP-agent worden gebruikt.

Voordelen:

• hoge gegevensoverdrachtsnelheid en hoge verwerkingssnelheid van verzoeken (1,5 - 6 keer hoger dan andere standaard RAID-niveaus);
• hoge schaalbaarheid van hostinterfaces;
• de schrijfsnelheid van gegevens neemt toe met het aantal schijven in de array;
• Er is geen extra gegevensoverdracht nodig om de pariteit te berekenen.

Gebreken:

• eigendom van één fabrikant;
• zeer hoge kosten per volume-eenheid;
• korte garantieperiode;
• kan niet door de gebruiker worden onderhouden;
• u moet een ononderbroken stroomvoorziening gebruiken om gegevensverlies uit het cachegeheugen te voorkomen.

Laten we nu samen naar de standaardniveaus kijken om hun kenmerken te vergelijken. De vergelijking wordt gemaakt binnen het kader van de in de tabel genoemde architecturen.

Verduidelijkingen:

• * - de meest gebruikte optie wordt overwogen;
• k - aantal subsegmenten;
• R - lezen;
• W - opnemen.

Enkele aspecten van het implementeren van RAID-systemen

Laten we drie hoofdopties bekijken voor het implementeren van RAID-systemen:

• software (softwaregebaseerd);
• hardware - busgebaseerd;
• hardware - autonoom subsysteem (gebaseerd op subsysteem).

Het is onmogelijk om ondubbelzinnig te zeggen dat de ene implementatie beter is dan de andere. Elke optie voor het organiseren van een array voldoet aan de behoeften van een of andere gebruiker, afhankelijk van de financiële mogelijkheden, het aantal gebruikers en de gebruikte applicaties.

Elk van de bovenstaande implementaties is gebaseerd op de uitvoering van programmacode. Ze verschillen feitelijk in de plaats waar deze code wordt uitgevoerd: in de centrale processor van de computer (software-implementatie) of in een gespecialiseerde processor op een RAID-controller (hardware-implementatie).

Het belangrijkste voordeel van software-implementatie is de lage kosten. Maar tegelijkertijd heeft het veel nadelen: lage prestaties, belasting van de centrale processor met extra werk en meer busverkeer. Eenvoudige RAID-niveaus 0 en 1 worden meestal in software geïmplementeerd, omdat ze geen aanzienlijke berekeningen vereisen. Rekening houdend met deze kenmerken, worden op software gebaseerde RAID-systemen gebruikt in servers op instapniveau.

Hardware RAID-implementaties kosten dus meer dan software-implementaties, omdat ze extra hardware gebruiken om I/O-bewerkingen uit te voeren. Tegelijkertijd ontlasten of maken ze de centrale processor en systeembus vrij en verhogen ze daarmee de prestaties.

Busgeoriënteerde implementaties zijn RAID-controllers die gebruik maken van de hogesnelheidsbus van de computer waarin ze zijn geïnstalleerd (de laatste tijd wordt meestal de PCI-bus gebruikt). Busgerichte implementaties kunnen op hun beurt worden onderverdeeld in low-level en high-level. De eerstgenoemde hebben doorgaans geen SCSI-chips en maken gebruik van de zogenaamde RAID-poort op het moederbord met ingebouwde SCSI-controller. In dit geval worden de functies voor het verwerken van RAID-code en I/O-bewerkingen verdeeld tussen de processor op de RAID-controller en de SCSI-chips op het moederbord. Zo wordt de centrale processor bevrijd van het verwerken van extra code en wordt het busverkeer verminderd in vergelijking met de softwareversie. De kosten van dergelijke borden zijn meestal laag, vooral als ze gericht zijn op RAID 0- of 1-systemen (er zijn ook implementaties van RAID 3, 5, 10, 30, 50, maar die zijn duurder), waardoor ze geleidelijk het verdringen van software-implementaties van de servermarkt op instapniveau. Hoogwaardige controllers met busimplementatie hebben een iets andere structuur dan hun jongere broers. Ze nemen alle functies over die verband houden met invoer/uitvoer en uitvoering van RAID-code. Bovendien zijn ze niet zo afhankelijk van de implementatie van het moederbord en hebben ze in de regel meer mogelijkheden (bijvoorbeeld de mogelijkheid om een ​​module aan te sluiten om informatie in de cache op te slaan bij een moederbordstoring of stroomstoring) . Dergelijke controllers zijn doorgaans duurder dan low-end controllers en worden gebruikt in mid- en high-end servers. Ze implementeren in de regel RAID-niveaus 0.1, 3, 5, 10, 30, 50. Gezien het feit dat busgeoriënteerde implementaties rechtstreeks op de interne PCI-bus van de computer zijn aangesloten, zijn ze de meest productieve van de systemen in kwestie ( bij het organiseren van systemen met één host). De maximale prestaties van dergelijke systemen kunnen 132 MB/s (32bit PCI) of 264 MB/s (64bit PCI) bereiken bij een busfrequentie van 33MHz.

Naast de genoemde voordelen heeft de busgeoriënteerde architectuur de volgende nadelen:

• afhankelijkheid van het besturingssysteem en platform;
• beperkte schaalbaarheid;
• beperkte mogelijkheden voor het organiseren van fouttolerante systemen.

Al deze nadelen kunnen worden vermeden door autonome subsystemen te gebruiken. Deze systemen hebben een volledig autonome externe organisatie en vormen in principe een aparte computer die wordt gebruikt om informatieopslagsystemen te organiseren. Als de glasvezelkanaaltechnologie zich succesvol ontwikkelt, zullen de prestaties van autonome systemen bovendien op geen enkele manier onderdoen voor die van busgeoriënteerde systemen.

Een externe controller wordt doorgaans in een apart rack geplaatst en kan, in tegenstelling tot systemen met een busorganisatie, een groot aantal invoer-/uitvoerkanalen hebben, inclusief hostkanalen, waardoor het mogelijk wordt meerdere hostcomputers op het systeem aan te sluiten en clusters te organiseren systemen. In systemen met een standalone controller kunnen hot standby controllers worden geïmplementeerd.

Een van de nadelen van autonome systemen zijn de hoge kosten.

Gezien het bovenstaande merken we op dat autonome controllers meestal worden gebruikt om gegevensopslag- en clustersystemen met hoge capaciteit te implementeren.

RAID-array (Redundant Array of Independent Disks) - verbindt meerdere apparaten om de prestaties en/of betrouwbaarheid van de gegevensopslag te verbeteren, kortom: een redundante array van onafhankelijke schijven.

Volgens de wet van Moore neemt de huidige productiviteit elk jaar toe (het aantal transistors op een chip verdubbelt namelijk elke twee jaar). Dit is te zien in bijna elke computerhardware-industrie. Processors vergroten het aantal kernen en transistors, terwijl het proces wordt verminderd, RAM verhoogt de frequentie en bandbreedte, het SSD-geheugen verhoogt de duurzaamheid en leessnelheid.

Maar eenvoudige harde schijven (HDD's) zijn de afgelopen tien jaar niet veel vooruitgegaan. Omdat de standaardsnelheid 7200 rpm was, blijft dit zo (zonder rekening te houden met server-HDD's met toerentallen van 10.000 of meer). Langzame 5400 rpm is nog steeds te vinden op laptops. Om de prestaties van hun computer te verbeteren, zal het voor de meeste gebruikers handiger zijn om een ​​SDD te kopen, maar de prijs voor 1 gigabyte van dergelijke media is veel hoger dan die van een eenvoudige HDD. “Hoe kan ik de prestaties van schijven verhogen zonder veel geld en volume te verliezen? Hoe kunt u uw gegevens opslaan of de veiligheid van uw gegevens verhogen? Er is een antwoord op deze vragen: een RAID-array.

Soorten RAID-arrays

Momenteel bestaan ​​de volgende typen RAID-arrays:

RAID 0 of "Striping"– een array van twee of meer schijven om de algehele prestaties te verbeteren. Het raid-volume zal totaal zijn (HDD 1 + HDD 2 = Totaal volume), de lees-/schrijfsnelheid zal hoger zijn (vanwege het opsplitsen van de opname in 2 apparaten), maar de betrouwbaarheid van de informatiebeveiliging zal eronder lijden. Als een van de apparaten uitvalt, gaat alle informatie in de array verloren.

RAID 1 of "Spiegel"– meerdere schijven kopiëren elkaar om de betrouwbaarheid te vergroten. De schrijfsnelheid blijft op hetzelfde niveau, de leessnelheid neemt toe, de betrouwbaarheid neemt vele malen toe (zelfs als het ene apparaat uitvalt, werkt het tweede), maar de kosten van 1 Gigabyte aan informatie stijgen met het dubbele (als je een array maakt van twee hdd's).

RAID 2 is een array die is gebouwd op schijven voor het opslaan van informatie en foutcorrectieschijven. Het aantal HDD's voor het opslaan van informatie wordt berekend met behulp van de formule "2^n-n-1", waarbij n het aantal HDD-correcties is. Dit type wordt gebruikt als er een groot aantal HDD's is, het minimaal acceptabele aantal is 7, waarbij 4 voor het opslaan van informatie is en 3 voor het opslaan van fouten. Het voordeel van dit type is een betere prestatie vergeleken met een enkele schijf.

RAID 3 – bestaat uit “n-1” schijven, waarbij n een schijf is voor het opslaan van pariteitsblokken, de rest zijn apparaten voor het opslaan van informatie. Informatie wordt opgedeeld in stukjes die kleiner zijn dan de sectorgrootte (verdeeld in bytes), zeer geschikt voor het werken met grote bestanden, de leessnelheid van kleine bestanden is erg laag. Gekenmerkt door hoge prestaties, maar lage betrouwbaarheid en beperkte specialisatie.

RAID 4 is vergelijkbaar met type 3, maar is verdeeld in blokken in plaats van in bytes. Deze oplossing kon de lage leessnelheid van kleine bestanden corrigeren, maar de schrijfsnelheid bleef laag.

RAID 5 en 6 - in plaats van een aparte schijf voor foutcorrelatie, zoals in eerdere versies, worden blokken gebruikt die gelijkmatig over alle apparaten zijn verdeeld. In dit geval neemt de snelheid van het lezen/schrijven van informatie toe als gevolg van de parallellisatie van de opname. Het nadeel van dit type is het langdurig herstellen van informatie in het geval van een storing van een van de schijven. Tijdens het herstel wordt er een zeer hoge belasting op andere apparaten uitgeoefend, waardoor de betrouwbaarheid afneemt en de uitval van een ander apparaat en het verlies van alle gegevens in de array toeneemt. Type 6 verbetert de algehele betrouwbaarheid, maar vermindert de prestaties.

Gecombineerde typen RAID-arrays:

RAID 01 (0+1) – Twee Raid 0's worden gecombineerd in Raid 1.

RAID 10 (1+0) – RAID 1-schijfarrays, die worden gebruikt in type 0-architectuur. Het wordt beschouwd als de meest betrouwbare optie voor gegevensopslag, waarbij hoge betrouwbaarheid en prestaties worden gecombineerd.

Je kunt ook een array maken van SSD-schijven. Volgens tests van 3DNews levert een dergelijke combinatie geen significante stijging op. Het is beter om een ​​schijf aan te schaffen met een krachtigere PCI- of eSATA-interface

Raid-array: hoe te creëren

Gemaakt door verbinding te maken via een speciale RAID-controller. Op dit moment zijn er 3 soorten controllers:

1. Software – de array wordt door software geëmuleerd, alle berekeningen worden uitgevoerd door de CPU.
2. Geïntegreerd – voornamelijk gebruikelijk op moederborden (niet in het serversegment). Een klein chipje aan de mat. bord dat verantwoordelijk is voor het emuleren van de array, berekeningen worden uitgevoerd via de CPU.
3. Hardware – een uitbreidingskaart (voor desktopcomputers), meestal met een PCI-interface, heeft zijn eigen geheugen en computerprocessor.

RAID hdd-array: Hoe maak je het van 2 schijven via IRST

Gegevensherstel

Enkele opties voor gegevensherstel:

1. Als Raid 0 of 5 mislukt, kan het hulpprogramma RAID Reconstructor helpen, dat de beschikbare schijfinformatie verzamelt en deze naar een ander apparaat of medium herschrijft in de vorm van een afbeelding van de vorige array. Deze optie helpt als de schijven goed werken en de fout softwarematig is.
2. Voor Linux-systemen wordt mdadm-herstel gebruikt (een hulpprogramma voor het beheren van software Raid-arrays).
3. Hardwareherstel moet worden uitgevoerd via gespecialiseerde diensten, omdat u zonder kennis van de bedieningsmethoden van de controller alle gegevens kunt verliezen en het zeer moeilijk of zelfs onmogelijk zal zijn om ze terug te krijgen.

Er zijn veel nuances waarmee rekening moet worden gehouden bij het maken van een Raid op uw computer. In principe worden de meeste opties gebruikt in het serversegment, waar datastabiliteit en beveiliging belangrijk en noodzakelijk zijn. Als je vragen of aanvullingen hebt, kun je deze achterlaten in de reacties.

Fijne dag!

Bijna iedereen kent het spreekwoord: ‘Totdat de donder inslaat, zal een man geen kruis slaan.’ Het is van vitaal belang: totdat dit of dat probleem de gebruiker van dichtbij raakt, zal hij er niet eens over nadenken. De stroomvoorziening viel uit en nam een ​​​​paar apparaten mee - de gebruiker haast zich om artikelen te zoeken over relevante onderwerpen over lekker en gezond eten. De processor is doorgebrand of begon defect te raken als gevolg van oververhitting - in de "Favorieten" verschijnen een paar links naar uitgebreide forumthreads waar CPU-koeling wordt besproken.

Het is hetzelfde verhaal met harde schijven: zodra de volgende schroef, nadat hij zijn kop heeft gekraakt, onze sterfelijke wereld verlaat, begint de eigenaar van de pc zich druk te maken om de verbetering van de levensomstandigheden van de schijf te garanderen. Maar zelfs de meest geavanceerde koeler kan geen lang en gelukkig leven voor de schijf garanderen. De levensduur van de schijf wordt door veel factoren beïnvloed: fabricagefouten en een onbedoelde schop tegen de behuizing (vooral als de behuizing ergens op de grond staat), stof dat door de filters dringt en hoogspanningsinterferentie die door de schijf wordt verzonden. voeding... Er is maar één uitweg: back-upinformatie, en als je onderweg back-up nodig hebt, dan is het tijd om een ​​RAID-array te bouwen, aangezien tegenwoordig bijna elk moederbord een soort RAID-controller heeft.

Op dit punt zullen we stoppen en een korte excursie maken naar de geschiedenis en theorie van RAID-arrays. De afkorting RAID zelf staat voor Redundant Array of Independent Disks. Vroeger werd goedkoop gebruikt in plaats van onafhankelijk, maar in de loop van de tijd heeft deze definitie zijn relevantie verloren: bijna alle schijfstations zijn goedkoop geworden.

De geschiedenis van RAID begon in 1987, toen het artikel "Enclosure for Redundant Arrays of Low-Cost Disks (RAID)" werd gepubliceerd, ondertekend door kameraden Peterson, Gibson en Katz. Het artikel beschreef de technologie van het combineren van verschillende gewone schijven in een array om een ​​snellere en betrouwbaardere schijf te verkrijgen. De auteurs van het materiaal vertelden de lezers ook over verschillende soorten arrays - van RAID-1 tot RAID-5. Vervolgens werd een RAID-array op nulniveau toegevoegd aan de arrays die bijna twintig jaar geleden werden beschreven, en deze won aan populariteit. Dus wat zijn al deze RAID-x? Wat is hun essentie? Waarom worden ze overbodig genoemd? Wij zullen proberen dit uit te zoeken.

In heel eenvoudige bewoordingen is RAID iets waardoor het besturingssysteem niet weet hoeveel schijven er in de computer zijn geïnstalleerd. Het combineren van harde schijven in een RAID-array is een proces dat lijnrecht tegenovergesteld is aan het verdelen van een enkele ruimte in logische schijven: we vormen één logische schijf op basis van meerdere fysieke schijven. Om dit te doen, hebben we de juiste software nodig (we zullen niet eens over deze optie praten - het is onnodig), of een RAID-controller ingebouwd in het moederbord, of een aparte die in een PCI of PCI Express is geplaatst. sleuf. Het is de controller die de schijven combineert tot een array, en het besturingssysteem werkt niet langer met de HDD, maar met de controller, die hem niets onnodigs vertelt. Maar er zijn heel veel opties om meerdere schijven te combineren tot één, meer precies, ongeveer tien.

Wat zijn RAID-typen?

De eenvoudigste daarvan is JBOD (Just a Bunch of Disks). Twee harde schijven worden in serie tot één vastgelijmd, informatie wordt eerst naar de ene en vervolgens naar de andere schijf geschreven zonder deze in stukken en blokken te breken. Van twee schijven van 200 GB maken we één schijf van 400 GB, die op vrijwel dezelfde, en in werkelijkheid iets lagere, snelheid werkt als elk van de twee schijven.

JBOD is een speciaal geval van een niveau-0-array, RAID-0. Er is ook een andere variant van de naam van arrays op dit niveau: stripe (strip), de volledige naam is Striped Disk Array without Fault Tolerance. Deze optie houdt ook in dat n schijven worden gecombineerd tot één met een capaciteit die n keer is vergroot, maar de schijven worden niet opeenvolgend gecombineerd, maar parallel, en er wordt informatie in blokken naar geschreven (de blokgrootte wordt door de gebruiker gespecificeerd bij het vormen van een RAID matrix).

Dat wil zeggen, als de reeks getallen 123456 moet worden geschreven naar twee schijven in een RAID-0-array, zal de controller deze keten in twee delen verdelen - 123 en 456 - en de eerste naar één schijf schrijven, en de tweede naar de andere. Elke schijf kan gegevens overbrengen... nou ja, met een snelheid van 50 MB/s, en de totale snelheid van twee schijven waarvan parallel gegevens worden opgehaald is 100 MB/s. De snelheid van het werken met gegevens zou dus n keer moeten toenemen (in werkelijkheid is de snelheidstoename natuurlijk minder, aangezien niemand de verliezen bij het zoeken naar gegevens en het verzenden ervan via de bus heeft geannuleerd). Maar deze toename is niet voor niets: als minstens één schijf uitvalt, gaat informatie uit de hele array verloren.

RAID-niveau nul. De gegevens worden in blokken verdeeld en over schijven verspreid. Er is geen sprake van pariteit of redundantie.

Dat wil zeggen dat er geen sprake is van redundantie en helemaal geen redundantie. Deze array kan alleen voorwaardelijk als een RAID-array worden beschouwd, maar is echter erg populair. Weinig mensen denken na over betrouwbaarheid; deze kan niet worden gemeten met benchmarks, maar iedereen begrijpt de taal van megabytes per seconde. Dit is niet slecht of goed, het gebeurt gewoon. Hieronder zullen we praten over hoe je de vis kunt eten en de betrouwbaarheid kunt behouden. RAID-0 herstellen na een storing

Een bijkomend nadeel van de stripe array is overigens dat deze niet draagbaar is. Ik bedoel niet dat hij bepaalde soorten voedsel of bijvoorbeeld zijn baasjes niet tolereert. Het kan hem niets schelen, maar het verplaatsen van de array zelf ergens heen is een heel probleem. Zelfs als u zowel de schijven als de controllerstuurprogramma's naar uw vriend sleept, is het geen feit dat ze als één array worden gedefinieerd en dat de gegevens kunnen worden gebruikt. Bovendien zijn er gevallen waarin het simpelweg aansluiten (zonder iets te schrijven!) Stripe-schijven op een "niet-native" (anders dan die waarop de array is gevormd) controller leidde tot schade aan de informatie in de array. We weten niet hoe relevant dit probleem nu is, met de komst van moderne controllers, maar we raden je toch aan voorzichtig te zijn.

Niveau 1 RAID-array van vier schijven. De schijven zijn in paren verdeeld en de schijven binnen het paar slaan dezelfde gegevens op.

De eerste echt "redundante" array (en de eerste RAID die verscheen) was RAID-1. De tweede naam - mirror - verklaart het werkingsprincipe: alle schijven die aan de array zijn toegewezen, worden in paren verdeeld en informatie wordt tegelijk naar beide schijven gelezen en geschreven. Het blijkt dat elk van de schijven in de array een exacte kopie heeft. In een dergelijk systeem neemt niet alleen de betrouwbaarheid van de gegevensopslag toe, maar ook de leessnelheid (je kunt vanaf twee harde schijven tegelijk lezen), hoewel de schrijfsnelheid hetzelfde blijft als die van één schijf.

Zoals je misschien wel vermoedt, zal het volume van zo'n array gelijk zijn aan de helft van de som van de volumes van alle harde schijven die erin zijn opgenomen. Het nadeel van deze oplossing is dat je twee keer zoveel harde schijven nodig hebt. Maar de betrouwbaarheid van deze array is eigenlijk niet eens gelijk aan de dubbele betrouwbaarheid van een enkele schijf, maar veel hoger dan deze waarde. Het uitvallen van twee harde schijven binnen... nou ja, laten we zeggen, een dag is onwaarschijnlijk, tenzij bijvoorbeeld de stroomvoorziening ingrijpt. Tegelijkertijd zal elk weldenkend mens, die ziet dat één schijf van een paar defect is, deze onmiddellijk vervangen, en zelfs als de tweede schijf onmiddellijk daarna uitvalt, zal de informatie nergens heen gaan.

Zoals u kunt zien, hebben zowel RAID-0 als RAID-1 hun nadelen. Hoe kan ik ze kwijtraken? Als u minimaal vier harde schijven heeft, kunt u een RAID 0+1-configuratie maken. Om dit te doen, worden RAID-1-arrays gecombineerd tot een RAID-0-array. Of andersom: soms wordt een RAID-1-array gemaakt uit verschillende RAID-0-arrays (het resultaat is RAID-10, met als enige voordeel een kortere gegevenshersteltijd wanneer één schijf uitvalt).

De betrouwbaarheid van een dergelijke configuratie van vier harde schijven is gelijk aan de betrouwbaarheid van een RAID-1 array, en de snelheid is eigenlijk hetzelfde als die van RAID-0 (in werkelijkheid zal deze hoogstwaarschijnlijk iets lager zijn vanwege de beperkte mogelijkheden van de controller). Tegelijkertijd betekent het gelijktijdig falen van twee schijven niet altijd een volledig verlies van informatie: dit zal alleen gebeuren als de schijven met dezelfde gegevens uitvallen, wat onwaarschijnlijk is. Dat wil zeggen, als vier schijven worden verdeeld in paren 1-2 en 3-4 en de paren worden gecombineerd in een RAID-0-array, dan zal alleen het gelijktijdig falen van schijven 1 en 2 of 3 en 4 leiden tot gegevensverlies, terwijl in het geval van het vroegtijdig overlijden van de eerste en de derde, tweede en vierde, eerste en vierde of tweede en derde harde schijf, blijven de gegevens veilig.

Het grootste nadeel van RAID-10 zijn echter de hoge kosten van schijven. Toch kan de prijs van vier (minimaal!) harde schijven niet klein worden genoemd, vooral als de capaciteit van slechts twee ervan daadwerkelijk voor ons beschikbaar is (weinig mensen denken na over betrouwbaarheid en hoeveel het kost, zoals we al hebben gezegd). Grote (100%) redundantie van gegevensopslag is voelbaar. Dit alles heeft ertoe geleid dat onlangs een array-variant genaamd RAID-5 aan populariteit heeft gewonnen. Om het te implementeren heb je drie schijven nodig. Naast de informatie zelf slaat de controller ook pariteitsblokken op de array-schijven op.

We zullen niet ingaan op de details van hoe het pariteitscontrolealgoritme werkt; we zullen alleen zeggen dat als informatie verloren gaat op een van de schijven, u deze kunt herstellen met behulp van pariteitsgegevens en live gegevens van andere schijven. Het pariteitsblok heeft het volume van één fysieke schijf en is gelijkmatig verdeeld over alle harde schijven van het systeem, zodat u bij verlies van een schijf informatie kunt herstellen met behulp van een pariteitsblok dat zich op een andere schijf van de array bevindt. De informatie wordt in grote blokken verdeeld en één voor één naar de schijven geschreven, dat wil zeggen volgens het 12-34-56-principe in het geval van een array met drie schijven.

Dienovereenkomstig is het totale volume van een dergelijke array het volume van alle schijven minus de capaciteit van één ervan. Gegevensherstel gebeurt uiteraard niet onmiddellijk, maar een dergelijk systeem heeft hoge prestaties en een betrouwbaarheidsmarge tegen minimale kosten (voor een array van 1000 GB heb je zes schijven van 200 GB nodig). De prestaties van zo’n array zullen echter nog steeds lager zijn dan de snelheid van een stripe-systeem: bij elke schrijfoperatie moet de controller ook de pariteitsindex bijwerken.

RAID-0, RAID-1 en RAID 0+1, soms ook RAID-5 - deze niveaus putten meestal de mogelijkheden van desktop RAID-controllers uit. Hogere niveaus zijn alleen beschikbaar voor complexe systemen op basis van SCSI-harde schijven. Gelukkige eigenaren van SATA-controllers met Matrix RAID-ondersteuning (dergelijke controllers zijn ingebouwd in de South Bridges ICH6R en ICH7R van Intel) kunnen echter profiteren van RAID-0- en RAID-1-arrays met slechts twee schijven, en degenen die een bord hebben met ICH7R kan RAID-5 en RAID-0 combineren als ze vier identieke schijven hebben.

Hoe wordt dit in de praktijk geïmplementeerd? Laten we eens kijken naar een eenvoudiger geval met RAID-0 en RAID-1. Stel dat u twee harde schijven van 400 GB hebt gekocht. U splitst elke schijf op in logische schijven van 100 GB en 300 GB. Daarna combineert u met behulp van het Intel Application Accelerator RAID Option ROM-hulpprogramma dat in het BIOS is ingebouwd, partities van 100 GB in een stripe-array (RAID-0) en partities van 300 GB in een Mirror-array (RAID-1). Nu kunt u op een snelle schijf met een capaciteit van 200 GB bijvoorbeeld speelgoed, videomateriaal en andere gegevens opslaan die een hoge snelheid van het schijfsubsysteem vereisen en bovendien niet erg belangrijk zijn (dat wil zeggen de gegevens die u wilt ik heb er niet zoveel spijt van dat ik het heb verloren), en op een gespiegelde schijf van 300 GB gigabyte verplaatst u werkdocumenten, e-mailarchieven, hulpprogramma's en andere essentiële bestanden. Als één schijf uitvalt, verliest u wat op de stripe-array was geplaatst, maar worden de gegevens die u op de tweede logische schijfeenheid hebt geplaatst, gedupliceerd op de resterende schijf.

Het combineren van de RAID-5- en RAID-0-niveaus betekent dat een deel van het volume van vier schijven wordt toegewezen voor een snelle stripe-array, en het andere deel (laat het 300 GB op elke schijf zijn) valt op datablokken en pariteitsblokken, die dat wil zeggen, u krijgt een ultrasnelle schijf van 400 GB (4 x 100 GB) en een betrouwbare maar langzamere array van 900 GB van 4 x 300 GB minus 300 GB voor pariteitsblokken.

Zoals je kunt zien is deze technologie zeer veelbelovend, en het zou mooi zijn als andere fabrikanten van chipsets en controllers dit ondersteunen. Het is erg verleidelijk om arrays van verschillende niveaus op twee schijven te hebben, snel en betrouwbaar.

Dit zijn misschien alle soorten RAID-arrays die in thuissystemen worden gebruikt. In het leven kun je echter RAID-2, 3, 4, 6 en 7 tegenkomen. Laten we dus nog eens kijken wat deze niveaus zijn.

RAID-2. In een array van dit type worden schijven in twee groepen verdeeld: voor gegevens en voor foutcorrectiecodes, en als de gegevens op n schijven zijn opgeslagen, zijn er n-1 schijven nodig om correctiecodes op te slaan. Gegevens worden op dezelfde manier naar de overeenkomstige harde schijven geschreven als in RAID-0. Ze worden in kleine blokken verdeeld op basis van het aantal schijven dat bedoeld is voor het opslaan van informatie. Op de overige schijven worden foutcorrectiecodes opgeslagen, die kunnen worden gebruikt om informatie te herstellen als een harde schijf defect raakt. De Hamming-methode wordt al lang gebruikt in het ECC-geheugen en maakt directe correctie mogelijk van kleine fouten van één bit als deze plotseling optreden, en als twee bits ten onrechte worden verzonden, wordt dit opnieuw gedetecteerd met behulp van pariteitssystemen. Niemand wilde voor dit doel echter een omvangrijke structuur van bijna het dubbele aantal schijven behouden, en dit type array werd niet wijdverspreid.

Array-structuur RAID-3 is dit: in een array van n schijven worden de gegevens opgesplitst in blokken van 1 byte en verdeeld over n-1 schijven, en een andere schijf wordt gebruikt om pariteitsblokken op te slaan. In RAID-2 waren er n-1 schijven voor dit doel, maar de meeste informatie op deze schijven werd alleen gebruikt voor foutcorrectie tijdens de vlucht, en voor eenvoudig herstel in het geval van een schijfstoring, een kleiner aantal ervan is genoeg, één speciale harde schijf is genoeg.

RAID-niveau 3 met een aparte schijf voor het opslaan van pariteitsinformatie. Er is geen back-up, maar de gegevens kunnen worden hersteld.

Dienovereenkomstig zijn de verschillen tussen RAID-3 en RAID-2 duidelijk: de onmogelijkheid van on-the-fly foutcorrectie en minder redundantie. De voordelen zijn als volgt: de snelheid van het lezen en schrijven van gegevens is hoog en er zijn zeer weinig schijven nodig om een ​​array te maken, slechts drie. Maar een array van dit type is alleen goed voor het werken met één taak met grote bestanden, omdat er snelheidsproblemen zijn bij frequente verzoeken om kleine gegevens.

Een niveau 5-array verschilt van RAID-3 doordat de pariteitsblokken gelijkmatig over alle schijven in de array zijn verdeeld.

RAID-4 vergelijkbaar met RAID-3, maar verschilt ervan doordat de gegevens in blokken zijn verdeeld in plaats van in bytes. Het was dus mogelijk om het probleem van de lage gegevensoverdrachtsnelheid van kleine volumes te “verslaan”. Het schrijven gaat langzaam vanwege het feit dat pariteit voor het blok wordt gegenereerd tijdens het opnemen en naar een enkele schijf wordt geschreven. Arrays van dit type worden zeer zelden gebruikt.

RAID-6- dit is dezelfde RAID-5, maar nu zijn er twee pariteitsblokken opgeslagen op elk van de array-schijven. Dus als twee schijven defect raken, kan informatie nog steeds worden hersteld. Uiteraard heeft de grotere betrouwbaarheid geleid tot een afname van het bruikbare volume aan schijven en een toename van hun minimumaantal: als er nu n schijven in de array zijn, zal het totale volume dat beschikbaar is voor het opnemen van gegevens gelijk zijn aan het volume van één schijf vermenigvuldigd met n-2. De noodzaak om twee checksums tegelijk te berekenen bepaalt het tweede nadeel dat RAID-6 heeft geërfd van RAID-5: de lage schrijfsnelheid van gegevens.

RAID-7 is een geregistreerd handelsmerk van Storage Computer Corporation. De structuur van de array is als volgt: gegevens worden opgeslagen op n-1 schijven, één schijf wordt gebruikt om pariteitsblokken op te slaan. Maar er zijn verschillende belangrijke details toegevoegd om het belangrijkste nadeel van dit soort arrays te elimineren: een datacache en een snelle controller die de verwerking van verzoeken beheert. Dit maakte het mogelijk om het aantal schijftoegangen te verminderen om de gegevenscontrolesom te berekenen. Als gevolg hiervan was het mogelijk om de snelheid van de gegevensverwerking aanzienlijk te verhogen (op sommige plaatsen vijf of meer keer).

RAID-niveau 0+1-array, of een ontwerp van twee RAID-1-arrays gecombineerd tot RAID-0. Betrouwbaar, snel, duur.

Er zijn ook nieuwe nadelen aan het licht gekomen: de zeer hoge kosten van het implementeren van een dergelijke array, de complexiteit van het onderhoud ervan, de behoefte aan een ononderbroken stroomvoorziening om gegevensverlies in het cachegeheugen tijdens stroomstoringen te voorkomen. Het is onwaarschijnlijk dat u een dergelijk array tegenkomt, maar als u het plotseling ergens tegenkomt, schrijf ons dan, wij kijken er ook graag naar.

Een array maken

Ik hoop dat het je al is gelukt om het arraytype te kiezen. Als je bord een RAID-controller heeft, heb je voor deze controller niets anders nodig dan het benodigde aantal schijven en drivers. Houd er trouwens rekening mee: het is logisch om alleen schijven van dezelfde grootte te combineren in arrays, bij voorkeur één model. De controller weigert mogelijk te werken met schijven van verschillende groottes, en hoogstwaarschijnlijk kunt u slechts een deel van een grote schijf gebruiken, dat qua volume gelijk is aan dat van de kleinere schijf. Bovendien zal zelfs de snelheid van een stripe-array worden bepaald door de snelheid van de langzaamste schijf. En mijn advies aan u: probeer de RAID-array niet opstartbaar te maken. Dit is mogelijk, maar als er fouten optreden in het systeem, zult u het moeilijk hebben, omdat het herstellen van de functionaliteit erg moeilijk zal zijn. Bovendien is het gevaarlijk om meerdere systemen op zo'n array te plaatsen: bijna alle programma's die verantwoordelijk zijn voor het selecteren van het besturingssysteem vernietigen informatie uit de servicegebieden van de harde schijf en beschadigen dienovereenkomstig de array. Het is beter om een ​​ander schema te kiezen: één schijf is opstartbaar en de rest wordt gecombineerd tot een array.

MatrixRAID in actie. Een deel van de schijfruimte wordt gebruikt door de RAID-0-array, de rest van de ruimte wordt ingenomen door de RAID-1-array.

Elke RAID-array begint met het BIOS van de RAID-controller. Soms (alleen in het geval van geïntegreerde controllers, en zelfs dan niet altijd) is het ingebouwd in het hoofd-BIOS van het moederbord, soms bevindt het zich afzonderlijk en wordt het geactiveerd nadat het de zelftest heeft doorstaan, maar in ieder geval moet je gaan daar. In het BIOS worden de noodzakelijke arrayparameters ingesteld, evenals de grootte van datablokken, de gebruikte harde schijven, enzovoort. Nadat u dit allemaal heeft bepaald, hoeft u alleen nog maar de instellingen op te slaan, het BIOS af te sluiten en terug te keren naar het besturingssysteem.

Daar moet je de controllerstuurprogramma's installeren (in de regel wordt een diskette meegeleverd met het moederbord of de controller zelf, maar ze kunnen met andere stuurprogramma's en hulpprogramma's naar een schijf worden geschreven), opnieuw opstarten, en dat is alles, de array is klaar voor gebruik. U kunt het opsplitsen in logische schijven, formatteren en vullen met gegevens. Houd er rekening mee dat RAID geen wondermiddel is. Het zal u behoeden voor gegevensverlies als uw harde schijf kapot gaat en de gevolgen van een dergelijke uitkomst minimaliseren, maar het zal u niet behoeden voor stroompieken en storingen van een voeding van lage kwaliteit, waardoor beide schijven in één keer worden uitgeschakeld, ongeacht hun capaciteit. “massiviteit.”

Het verwaarlozen van hoogwaardige stroomvoorziening en temperatuuromstandigheden van de schijven kan de levensduur van de HDD aanzienlijk verkorten. Het komt voor dat alle schijven in de array defect raken en alle gegevens onherstelbaar verloren gaan. Met name moderne harde schijven (vooral IBM en Hitachi) zijn erg gevoelig voor het +12 V-kanaal en houden niet van zelfs de kleinste spanningsverandering erop, dus voordat je alle apparatuur aanschaft die nodig is om de array te bouwen, is het de moeite waard om te controleren de bijbehorende spanningen en indien nodig een nieuwe BP aan het boodschappenlijstje toevoegen.

Het voeden van harde schijven, evenals alle andere componenten, vanaf een tweede voeding is op het eerste gezicht eenvoudig te implementeren, maar er zijn veel valkuilen in een dergelijk voedingsschema, en je moet honderd keer nadenken voordat je besluit te nemen zo'n stap. Met koeling is alles eenvoudiger: u hoeft alleen maar voor de luchtstroom voor alle harde schijven te zorgen en ze niet dicht bij elkaar te plaatsen. Eenvoudige regels, maar helaas volgt niet iedereen ze. En gevallen waarin beide schijven in een array tegelijkertijd doodgaan, zijn niet ongewoon.

Bovendien vervangt RAID niet de noodzaak om regelmatig een back-up van uw gegevens te maken. Spiegelen is spiegelen, maar als je per ongeluk bestanden beschadigt of wist, zal de tweede schijf je helemaal niet helpen. Maak dus back-ups wanneer je maar kunt. Deze regel is van toepassing ongeacht de aanwezigheid van RAID-arrays in de pc.

Dus, ben jij RAIDy? Ja? Geweldig! Als je volume en snelheid nastreeft, vergeet dan niet nog een spreekwoord: “Laat een dwaas tot God bidden, hij zal zijn voorhoofd breken.” Wij wensen u sterke schijven en betrouwbare controllers!

Kostenvoordeel van luidruchtige RAID

RAID is goed, zelfs zonder rekening te houden met geld. Maar laten we de prijs berekenen van de eenvoudigste stripe-array van 400 GB. Twee Seagate Barracuda SATA 7200.8-schijven van elk 200 GB kosten ongeveer $ 230. RAID-controllers zijn in de meeste moederborden ingebouwd, wat betekent dat we ze gratis krijgen.

Tegelijkertijd kost een schijf van 400 GB van hetzelfde model $ 280. Het verschil is $50, en met dat geld kun je een krachtige voeding kopen, die je ongetwijfeld nodig zult hebben. Ik heb het niet eens over het feit dat de prestaties van een samengestelde "schijf" tegen een lagere prijs bijna twee keer zo hoog zullen zijn als de prestaties van een enkele harde schijf.

Laten we nu de berekening uitvoeren, waarbij we ons concentreren op het totale volume van 250 GB. Er zijn geen schijven van 125 GB, dus laten we twee harde schijven van 120 GB nemen. De prijs van elke schijf is $90, de prijs van een harde schijf van 250 GB is $130. Bij zulke volumes heeft prestatie een prijs. Wat als we een array van 300 GB nemen? Twee schijven van 160 GB - ongeveer $200, één van 300 GB - $170... Niet weer hetzelfde. Het blijkt dat RAID alleen nuttig is bij gebruik van zeer grote schijven.

Harde schijven spelen een belangrijke rol in een computer. Ze slaan verschillende gebruikersinformatie op, starten het besturingssysteem van daaruit, enz. Harde schijven gaan niet eeuwig mee en hebben een zekere veiligheidsmarge. En elke harde schijf heeft zijn eigen onderscheidende kenmerken.

Hoogstwaarschijnlijk heb je ooit gehoord dat zogenaamde raid-arrays kunnen worden gemaakt van gewone harde schijven. Dit is nodig om de prestaties van schijven te verbeteren en de betrouwbaarheid van informatieopslag te garanderen. Bovendien kunnen dergelijke arrays hun eigen nummers hebben (0, 1, 2, 3, 4, enz.). In dit artikel vertellen we je over RAID-arrays.

INVAL is een verzameling harde schijven of een schijfarray. Zoals we al hebben gezegd, zorgt een dergelijke array voor een betrouwbare gegevensopslag en verhoogt ook de snelheid van het lezen of schrijven van informatie. Er zijn verschillende RAID-arrayconfiguraties, die zijn gemarkeerd met de cijfers 1, 2, 3, 4, enz. en verschillen in de functies die ze vervullen. Door dergelijke arrays met configuratie 0 te gebruiken, krijgt u aanzienlijke prestatieverbeteringen. Eén enkele RAID-array garandeert volledige veiligheid van uw gegevens, want als een van de schijven uitvalt, wordt de informatie op de tweede harde schijf geplaatst.

In wezen RAID-array– dit zijn 2 of n aantal harde schijven die op het moederbord zijn aangesloten, wat de mogelijkheid ondersteunt om raids te maken. Programmatisch kunt u de raid-configuratie selecteren, dat wil zeggen specificeren hoe dezelfde schijven moeten werken. Om dit te doen, moet u de instellingen in het BIOS opgeven.

Om de array te installeren hebben we een moederbord nodig dat raid-technologie ondersteunt, 2 identieke (in alle opzichten) harde schijven, die we op het moederbord aansluiten. In het BIOS moet u de parameter instellen SATA-configuratie: INVAL. Wanneer de computer opstart, drukt u op de toetsencombinatie CTR-I, en daar configureren we RAID al. En daarna installeren we Windows zoals gewoonlijk.

Het is de moeite waard om op te letten dat als u een raid maakt of verwijdert, alle informatie op de schijven wordt verwijderd. Daarom moet u er eerst een kopie van maken.

Laten we eens kijken naar de RAID-configuraties waar we het al over hadden. Er zijn er verschillende: RAID 1, RAID 2, RAID 3, RAID 4, RAID 5, RAID 6, enz.

RAID-0 (striping), ook wel een array op nulniveau of “null array” genoemd. Dit niveau verhoogt de snelheid van het werken met schijven met een orde van grootte, maar biedt geen extra fouttolerantie. In feite is deze configuratie puur formeel een raid-array, omdat er bij deze configuratie geen sprake is van redundantie. Opname in een dergelijke bundel vindt plaats in blokken, afwisselend geschreven naar verschillende schijven van de array. Het grootste nadeel hier is de onbetrouwbaarheid van de gegevensopslag: als een van de array-schijven uitvalt, wordt alle informatie vernietigd. Waarom gebeurt dit? Dit gebeurt omdat elk bestand in blokken naar meerdere harde schijven tegelijk kan worden geschreven, en als een van deze niet goed functioneert, wordt de integriteit van het bestand geschonden en is het daarom niet mogelijk om het te herstellen. Als u waarde hecht aan prestaties en regelmatig back-ups maakt, kan dit array-niveau op uw thuis-pc worden gebruikt, wat een merkbare prestatieverbetering zal opleveren.

RAID-1 (spiegelen)– “spiegelmodus”. Je kunt dit niveau van RAID-arrays het paranoïde niveau noemen: deze modus geeft vrijwel geen verbetering in de systeemprestaties, maar beschermt je gegevens absoluut tegen schade. Zelfs als een van de schijven defect raakt, wordt er een exacte kopie van de verloren schijf op een andere schijf opgeslagen. Deze modus kan, net als de eerste, ook op een thuis-pc worden geïmplementeerd voor mensen die de gegevens op hun schijven extreem hoog waarderen.

Bij het construeren van deze arrays wordt een algoritme voor informatieherstel gebruikt met behulp van Hamming-codes (een Amerikaanse ingenieur die dit algoritme in 1950 ontwikkelde om fouten in de werking van elektromechanische computers te corrigeren). Om de werking van deze RAID-controller te garanderen, zijn er twee groepen schijven gemaakt: één voor het opslaan van gegevens, de tweede groep voor het opslaan van foutcorrectiecodes.

Dit type RAID is minder wijdverspreid geworden in thuissystemen vanwege de buitensporige redundantie van het aantal harde schijven - in een array van zeven harde schijven worden er bijvoorbeeld slechts vier toegewezen voor gegevens. Naarmate het aantal schijven toeneemt, neemt de redundantie af, wat wordt weerspiegeld in de onderstaande tabel.

Het belangrijkste voordeel van RAID 2 is de mogelijkheid om fouten direct te corrigeren zonder de snelheid van de gegevensuitwisseling tussen de disk-array en de centrale processor te verminderen.

RAID3 en RAID4

Deze twee typen schijfarrays lijken qua ontwerp sterk op elkaar. Beide gebruiken meerdere harde schijven om informatie op te slaan, waarvan er één uitsluitend wordt gebruikt voor het opslaan van controlesommen. Drie harde schijven zijn voldoende om RAID 3 en RAID 4 te creëren. In tegenstelling tot RAID 2 is gegevensherstel niet direct mogelijk: informatie wordt hersteld nadat een defecte harde schijf gedurende een bepaalde periode is vervangen.

Het verschil tussen RAID 3 en RAID 4 is het niveau van gegevenspartitionering. In RAID 3 wordt informatie opgesplitst in individuele bytes, wat leidt tot ernstige vertraging bij het schrijven/lezen van een groot aantal kleine bestanden. RAID 4 splitst gegevens op in afzonderlijke blokken, waarvan de grootte niet groter is dan de grootte van één sector op de schijf. Als gevolg hiervan neemt de verwerkingssnelheid van kleine bestanden toe, wat van cruciaal belang is voor pc's. Om deze reden is RAID 4 wijdverspreider geworden.

Een aanzienlijk nadeel van de beschouwde arrays is de verhoogde belasting van de harde schijf die bedoeld is voor het opslaan van controlesommen, waardoor de hulpbronnen aanzienlijk worden verminderd.

RAID-5. De zogenaamde fouttolerante reeks onafhankelijke schijven met gedistribueerde opslag van controlesommen. Dit betekent dat op een array van n schijven n-1 schijf wordt toegewezen voor directe gegevensopslag, en dat de laatste de controlesom van de n-1 stripe-iteratie zal opslaan. Laten we, om het duidelijker uit te leggen, ons voorstellen dat we een bestand moeten schrijven. Het zal worden verdeeld in delen van dezelfde lengte en zal afwisselend cyclisch naar alle n-1 schijven worden geschreven. Een controlesom van bytes van datagedeelten van elke iteratie zal naar de laatste schijf worden geschreven, waar de controlesom zal worden geïmplementeerd door een bitsgewijze XOR-bewerking.

Het is de moeite waard om meteen te waarschuwen dat als een van de schijven uitvalt, deze allemaal in de noodmodus zullen gaan, wat de prestaties aanzienlijk zal verminderen, omdat Om het bestand samen te stellen, worden onnodige manipulaties uitgevoerd om de “ontbrekende” delen te herstellen. Als twee of meer schijven tegelijkertijd defect raken, kan de informatie die daarop is opgeslagen niet worden hersteld. Over het algemeen biedt de implementatie van een level 5 raid-array redelijk hoge toegangssnelheden, parallelle toegang tot verschillende bestanden en een goede fouttolerantie.

Het bovenstaande probleem wordt grotendeels opgelost door arrays te construeren met behulp van het RAID 6-schema. In deze structuren wordt een geheugenvolume toegewezen dat gelijk is aan het volume van twee harde schijven voor het opslaan van controlesommen, die ook cyclisch en gelijkmatig over verschillende schijven worden verdeeld. . In plaats van één worden er twee checksums berekend, wat de data-integriteit garandeert in het geval van gelijktijdig falen van twee harde schijven in de array.

De voordelen van RAID 6 zijn een hoge mate van informatiebeveiliging en minder prestatieverlies dan bij RAID 5 bij dataherstel bij het vervangen van een beschadigde schijf.

Het nadeel van RAID 6 is dat de algehele snelheid van gegevensuitwisseling met ongeveer 10% wordt verminderd als gevolg van een toename van het volume van de noodzakelijke controlesomberekeningen, maar ook als gevolg van een toename van de hoeveelheid geschreven/gelezen informatie.

Gecombineerde RAID-typen

Naast de hierboven besproken hoofdtypen worden er op grote schaal verschillende combinaties ervan gebruikt, die bepaalde nadelen van eenvoudige RAID compenseren. Met name het gebruik van RAID 10- en RAID 0+1-schema's is wijdverbreid. In het eerste geval worden een paar gespiegelde arrays gecombineerd tot RAID 0, in het tweede geval worden twee RAID 0 daarentegen gecombineerd tot een spiegel. In beide gevallen worden de verhoogde prestaties van RAID 0 toegevoegd aan de informatiebeveiliging van RAID 1.

Om het beschermingsniveau van belangrijke informatie te verhogen, worden vaak RAID 51- of RAID 61-constructieschema's gebruikt - het spiegelen van reeds sterk beveiligde arrays zorgt voor uitzonderlijke gegevensveiligheid in het geval van eventuele storingen. Het is echter onpraktisch om dergelijke arrays thuis te implementeren vanwege overmatige redundantie.

Een diskarray bouwen - van theorie naar praktijk

Een gespecialiseerde RAID-controller is verantwoordelijk voor het bouwen en beheren van de werking van elke RAID. Tot grote opluchting van de gemiddelde pc-gebruiker zijn deze controllers in de meeste moderne moederborden al geïmplementeerd op het chipset-southbridge-niveau. Om dus een reeks harde schijven te bouwen, hoeft u alleen maar het vereiste aantal harde schijven aan te schaffen en het gewenste RAID-type te bepalen in de juiste sectie van de BIOS-instellingen. Hierna ziet u in plaats van meerdere harde schijven in het systeem er slechts één, die desgewenst kan worden onderverdeeld in partities en logische schijven. Houd er rekening mee dat degenen die nog steeds Windows XP gebruiken een extra stuurprogramma moeten installeren.

En tot slot nog een advies: om een ​​RAID te maken, koopt u harde schijven met dezelfde capaciteit, dezelfde fabrikant, hetzelfde model en bij voorkeur uit dezelfde batch. Dan zullen ze worden uitgerust met dezelfde logicasets en zal de werking van de array van deze harde schijven het meest stabiel zijn.

Leonid Borislavski /wp-content/uploads/2018/05/logo.svg?1Leonid Borislavski 2017-01-16 08:57:09 2017-01-16 07:12:59 Wat zijn RAID-arrays en waarom zijn ze nodig?

Als u een van de volgende problemen op uw computer bent tegengekomen of verwacht binnenkort tegen te komen:

• Er is duidelijk niet genoeg fysieke capaciteit van de harde schijf als een enkele logische schijf. Meestal treedt dit probleem op bij het werken met grote bestanden (video, afbeeldingen, databases);
• De prestaties van de harde schijf zijn duidelijk niet voldoende. Meestal treedt dit probleem op bij het werken met niet-lineaire videobewerkingssystemen of wanneer een groot aantal gebruikers tegelijkertijd toegang heeft tot bestanden op de harde schijf;
• De betrouwbaarheid van de harde schijf laat duidelijk te wensen over. Meestal doet dit probleem zich voor wanneer er moet worden gewerkt met gegevens die nooit verloren mogen gaan of die altijd beschikbaar moeten zijn voor de gebruiker.

De trieste ervaring leert dat zelfs de meest betrouwbare apparatuur soms kapot gaat, en in de regel op het meest ongelegen moment.

Het creëren van een RAID-systeem op uw computer kan deze en enkele andere problemen oplossen.

Wat is "RAID"?

Het is bekend dat de gemiddelde tijd tussen storingen van een drive-array gelijk is aan de gemiddelde tijd tussen storingen van een enkele schijf gedeeld door het aantal schijven in de array. Als gevolg hiervan is de array-MTBF voor veel toepassingen te kort. Een disk-array kan echter op verschillende manieren tolerant worden gemaakt voor het falen van een enkele schijf.

In dit artikel zijn vijf typen (niveaus) schijfarrays gedefinieerd: RAID-1, RAID-2, ..., RAID-5. Elk type bood fouttolerantie en verschillende voordelen ten opzichte van een enkele schijf. Naast deze vijf typen heeft ook de RAID-0-schijfarray, die NIET redundant is, aan populariteit gewonnen.

Welke RAID-niveaus zijn er en welke moet je kiezen?

RAID-0. Meestal gedefinieerd als een niet-redundante groep schijfstations zonder pariteit. RAID-0 wordt soms “Striping” genoemd, gebaseerd op de manier waarop informatie op de schijven in de array wordt geplaatst:

Omdat RAID-0 geen redundantie heeft, leidt het falen van één schijf tot het falen van de hele array. Aan de andere kant biedt RAID-0 maximale gegevensoverdrachtsnelheid en efficiënt gebruik van schijfruimte. Omdat RAID-0 geen complexe wiskundige of logische berekeningen vereist, zijn de implementatiekosten minimaal.

Toepassingsgebied: audio- en videotoepassingen die continue gegevensoverdracht op hoge snelheid vereisen, wat niet door één enkele schijf kan worden geleverd. Uit onderzoeken uitgevoerd door Mylex om de optimale schijfsysteemconfiguratie voor een niet-lineair videobewerkingsstation te bepalen, blijkt bijvoorbeeld dat, vergeleken met een enkele schijf, een RAID-0-array van twee schijven een toename van 96% in schrijf-/leessnelheid oplevert. van drie schijven - met 143% (volgens de Miro VIDEO EXPERT Benchmark-test).

RAID-1. Beter bekend als "Mirroring" ("schijfspiegel") of een paar schijfstations die dezelfde informatie bevatten en één logische schijf vormen:

Rijd 0	Rijd 1

Er wordt op beide schijven in elk paar opgenomen. Schijven in een paar kunnen echter gelijktijdige leesbewerkingen uitvoeren. Zo kan "spiegelen" de leessnelheid verdubbelen, maar de schrijfsnelheid blijft ongewijzigd. RAID-1 heeft 100% redundantie en een storing van één schijf leidt niet tot een storing van de hele array; de controller schakelt eenvoudigweg lees-/schrijfbewerkingen over naar de resterende schijf.

RAID-1 biedt de snelste prestaties van elk type redundante array, vooral in een omgeving met meerdere gebruikers, maar het slechtste gebruik van schijfruimte. Omdat RAID-1 geen complexe wiskundige of logische berekeningen vereist, zijn de implementatiekosten minimaal.

Het minimumaantal schijven in de array is 2.

Om de schrijfsnelheid te verhogen en de betrouwbaarheid van de gegevensopslag te garanderen, kunnen verschillende RAID-1-arrays op hun beurt worden gecombineerd tot RAID-0. Deze configuratie wordt “two-level” RAID of RAID-10 (RAID 0+1) genoemd

Het minimumaantal schijven in de array is 4.

Toepassingsgebied: goedkope arrays waarbij de betrouwbaarheid van de gegevensopslag centraal staat.

RAID-2. Verdeelt gegevens in strepen ter grootte van een sector over een groep schijfstations. Sommige schijven zijn bestemd voor ECC-opslag (Error Correction Code). Omdat de meeste schijven standaard ECC-codes per sector opslaan, biedt RAID-2 niet veel voordeel ten opzichte van RAID-3 en wordt daarom in de praktijk niet gebruikt.

RAID-3. Net als in het geval van RAID-2 worden gegevens verdeeld over strepen van één sector groot, en wordt een van de array-schijven toegewezen om pariteitsinformatie op te slaan:

RAID-3 vertrouwt op ECC-codes die in elke sector zijn opgeslagen om fouten te detecteren. Als een van de schijven uitvalt, kan de informatie die erop is opgeslagen worden hersteld door exclusieve OR (XOR) te berekenen met behulp van de informatie op de overige schijven. Elke record wordt doorgaans over alle schijven verdeeld en daarom is dit type array goed voor schijfintensieve toepassingen. Omdat elke I/O-bewerking toegang heeft tot alle schijfstations in de array, kan RAID-3 niet meerdere bewerkingen tegelijkertijd uitvoeren. Daarom is RAID-3 goed voor omgevingen met één gebruiker en één taak en met lange records. Om met korte platen te werken, is het noodzakelijk om de rotatie van de schijfstations te synchroniseren, omdat anders een afname van de uitwisselingssnelheid onvermijdelijk is. Zelden gebruikt, omdat inferieur aan RAID-5 wat betreft schijfruimtegebruik. De implementatie vergt aanzienlijke kosten.

RAID-4. RAID-4 is identiek aan RAID-3, behalve dat de stripegrootte veel groter is dan één sector. In dit geval worden de leesbewerkingen uitgevoerd vanaf één enkele schijf (de schijf waarop pariteitsinformatie wordt opgeslagen niet meegerekend), zodat meerdere leesbewerkingen tegelijkertijd kunnen worden uitgevoerd. Omdat elke schrijfbewerking echter de inhoud van het pariteitsstation moet bijwerken, is het niet mogelijk om meerdere schrijfbewerkingen tegelijkertijd uit te voeren. Dit type array heeft geen merkbare voordelen ten opzichte van een RAID-5-array.

RAID-5. Dit type array wordt ook wel een "roterende pariteitsarray" genoemd. Dit type array overwint met succes het inherente nadeel van RAID-4: het onvermogen om meerdere schrijfbewerkingen tegelijkertijd uit te voeren. Deze array gebruikt, net als RAID-4, grote strepen, maar in tegenstelling tot RAID-4 wordt pariteitsinformatie niet op één schijf opgeslagen, maar op zijn beurt op alle schijven:

Schrijfbewerkingen hebben toegang tot één schijf met gegevens en een andere schijf met pariteitsinformatie. Omdat de pariteitsinformatie voor verschillende strips op verschillende schijven wordt opgeslagen, is het uitvoeren van meerdere gelijktijdige schrijfbewerkingen alleen onmogelijk in de zeldzame gevallen waarin de datastrips of de strepen met pariteitsinformatie zich op dezelfde schijf bevinden. Hoe meer schijven in de array, hoe minder vaak de locatie van de informatie- en pariteitsstrepen samenvalt.

Toepassingsgebied: betrouwbare arrays met groot volume. De implementatie vergt aanzienlijke kosten.

Het minimumaantal schijven in de array is 3.

RAID-1 of RAID-5?

RAID-5 maakt, vergeleken met RAID-1, zuiniger gebruik van schijfruimte, omdat het voor redundantie geen "kopie" van informatie opslaat, maar een controlenummer. Als gevolg hiervan kan RAID-5 een willekeurig aantal schijven combineren, waarvan er slechts één redundante informatie zal bevatten.

Maar een hogere schijfruimte-efficiëntie gaat ten koste van lagere informatie-uitwisselingssnelheden. Bij het schrijven van informatie naar RAID-5 moet de pariteitsinformatie elke keer worden bijgewerkt. Om dit te doen, moet u bepalen welke pariteitsbits zijn gewijzigd. Eerst wordt de oude informatie die moet worden bijgewerkt, gelezen. Deze informatie wordt vervolgens XORed met de nieuwe informatie. Het resultaat van deze bewerking is een bitmasker waarin elke bit =1 betekent dat de waarde in de pariteitsinformatie op de overeenkomstige positie moet worden vervangen. De bijgewerkte pariteitsinformatie wordt vervolgens naar de juiste locatie geschreven. Daarom voert RAID-5 voor elk programmaverzoek om informatie te schrijven twee lees-, twee schrijf- en twee XOR-bewerkingen uit.

Er zijn kosten verbonden aan het efficiënter gebruiken van schijfruimte (het opslaan van een pariteitsblok in plaats van een kopie van de gegevens): er is extra tijd nodig om pariteitsinformatie te genereren en te schrijven. Dit betekent dat de schrijfsnelheid op RAID-5 lager is dan op RAID-1 met een verhouding van 3:5 of zelfs 1:3 (d.w.z. de schrijfsnelheid op RAID-5 is 3/5 tot 1/3 van de schrijfsnelheid RAID-1). Hierdoor is het zinloos om RAID-5 in software te creëren. Ze kunnen ook niet worden aanbevolen in gevallen waarin de opnamesnelheid van cruciaal belang is.

Welke RAID-implementatiemethode moet u kiezen: software of hardware?

Na het lezen van de beschrijvingen van de verschillende RAID-niveaus zul je merken dat er nergens sprake is van specifieke hardwarevereisten die nodig zijn om RAID te implementeren. Hieruit kunnen we concluderen dat het enige dat nodig is om RAID te implementeren, het aansluiten van het vereiste aantal schijfstations op de beschikbare controller op de computer is en het installeren van speciale software op de computer. Dit is waar, maar niet helemaal!

Het is inderdaad mogelijk om RAID softwarematig te implementeren. Een voorbeeld is het Microsoft Windows NT 4.0 Server OS, waarin software-implementatie van RAID-0, -1 en zelfs RAID-5 mogelijk is. Deze oplossing moet echter als extreem vereenvoudigd worden beschouwd en maakt het niet mogelijk om de mogelijkheden van een RAID-array volledig te realiseren. Het volstaat op te merken dat bij de software-implementatie van RAID de hele last van het plaatsen van informatie op schijfstations, het berekenen van besturingscodes, enz. vallen op de centrale processor, wat de prestaties en betrouwbaarheid van het systeem uiteraard niet verhoogt. Om dezelfde redenen zijn er hier vrijwel geen servicefuncties en worden alle handelingen om een ​​defecte schijf te vervangen, een nieuwe schijf toe te voegen, het RAID-niveau te wijzigen, enz. uitgevoerd met volledig gegevensverlies en met het volledige verbod om enige andere actie uit te voeren. operaties. Het enige voordeel van de software-implementatie van RAID zijn de minimale kosten.

Veel meer mogelijkheden worden geboden door hardware-implementatie van RAID met behulp van speciale RAID-controllers:

• een gespecialiseerde controller ontlast de centrale processor aanzienlijk van RAID-bewerkingen, en de effectiviteit van de controller is merkbaarder naarmate het complexiteitsniveau van de RAID hoger is;
• controllers zijn in de regel uitgerust met stuurprogramma's waarmee u RAID kunt creëren voor vrijwel elk populair besturingssysteem;
• Dankzij het ingebouwde BIOS en de meegeleverde beheerprogramma's van de controller kan de systeembeheerder eenvoudig schijven in RAID aansluiten, loskoppelen of vervangen, meerdere RAID-arrays creëren, zelfs op verschillende niveaus, de status van de disk-array controleren, enz. Met “geavanceerde” controllers kunnen deze handelingen “on the fly” worden uitgevoerd, d.w.z. zonder de systeemeenheid uit te schakelen. Veel bewerkingen kunnen op de “achtergrond” worden uitgevoerd, d.w.z.
• zonder het huidige werk te onderbreken en zelfs op afstand, d.w.z. vanaf elke (natuurlijk, als u toegang heeft) werkplek;

Het nadeel van hardware RAID-implementatie zijn de relatief hoge kosten van RAID-controllers. Aan de ene kant moet je echter voor alles betalen (betrouwbaarheid, snelheid, service). Aan de andere kant begonnen onlangs, met de ontwikkeling van microprocessortechnologie, de kosten van RAID-controllers (vooral jongere modellen) scherp te dalen en werden ze vergelijkbaar met de kosten van gewone schijfcontrollers, wat het mogelijk maakt om RAID-systemen te installeren, niet alleen in dure mainframes, maar ook in instapservers en zelfs tot werkstations.