Instructeur: In deze
les gaan we het hebben over ECC geheugen,
bekend als foutcorrigerende code.
Maar eerst moeten we het concept van
non-pariteit en pariteit in termen van geheugen behandelen.
Als we het nu hebben over niet-pariteit, dan
is dit geheugen gewoon standaard geheugen.
Het controleert niet op fouten en staat toe dat gegevens
naar believen in het geheugen worden geplaatst of eruit worden
gehaald en dit is wat het meeste geheugen zal zijn.
Niet-pariteitsgeheugen is erg goedkoop om te maken
en het heeft een hogere snelheid dan pariteitsgeheugen.
Het pariteitsgeheugen daarentegen wordt
gebruikt om basisfoutcontroles uit te voeren en
om ervoor te zorgen dat de geheugeninhoud
betrouwbaar en integer is.
Hierdoor zal dit geheugen
langzamer zijn dan niet-pariteitsgeheugen,
maar het heeft wel de betrouwbaarheid
die nodig is voor servers en bepaalde
high-end desktop werkstations.
Nu kan een geheugen met een pariteitscontrole
een basisberekening uitvoeren op basis
van wat het ziet om te controleren
of de gegevens goed zijn of niet.
En als die gegevens goed zijn, zullen ze worden gebruikt.
En als dat niet zo is, treedt er een fout op, maar kan
deze niet worden opgelost.
Het zal gewoon kunnen zeggen dat er hier een fout is, maar
ik weet niet hoe ik het moet oplossen.
In principe werkt dit door aan elke byte
een pariteitsbit te koppelen.
Dus in plaats van acht bits, heb je nu negen bits,
want acht databits plus één bit voor pariteit.
Nu wordt de pariteitsbit op het juiste moment ingesteld.
En dan wordt het berekend en vergeleken
wanneer je uit het geheugen leest om te bepalen
of er bits zijn veranderd sinds die gegevens
voor het laatst in het geheugen zijn geschreven.
Dit type controle is echter
beperkt tot het detecteren van die enkele bitfouten.
En als er twee bits zijn gewijzigd,
kan die pariteitscontrole wel slagen,
want onthoud dat bits alleen een 0 of een 1 kunnen zijn.
Laten we bijvoorbeeld zeggen dat ik het getal
0 heb opgeslagen,
dat in het binair wordt geschreven als 00000000.
Als ik nu al deze bits bij elkaar optel, krijg ik acht 0's
en dat geeft me 0 voor mijn pariteitsbit.
Als ik nu dat getal uit het geheugen ga lezen
en ik zie dat er acht 0's zijn,
dan tel ik die bij elkaar op en krijg ik 0, 0
komt overeen met mijn pariteitsbit
als 0, dus dit is goede data.
Aan de andere
kant, stel dat ik het getal
1 opschrijf, dat wordt geschreven als 00000001.
Als ik nu al deze getallen bij elkaar optel, krijg ik 1.
En dat zet ik in mijn pariteit van het negende stukje.
Door dit te doen, lees ik nu daaruit
en krijg ik 00000001.
En omdat alles bij elkaar opgeteld
1 is en dat overeenkomt
met mijn pariteitsbit, weet ik
dat de gegevens goed zijn.
Maar als ik dat in het geheugen zet en
het heeft daar een paar uur gezeten en die 1 is per ongeluk
veranderd in een 0, als ik
dat nu lees en ik krijg 00000000, en ik tel die bij elkaar op, dan krijg ik
0, en ik vergelijk dat met mijn
pariteitsbit waar een 1 in zat,
dan vertelt me dat er een fout
is gemaakt en dat er iets is misgegaan.
Ik weet niet welke van die acht bits zijn veranderd,
maar in ieder geval één ervan.
Aan de andere
kant, als
dat getal van 00000001 werd veranderd in iets
als 01010001, had ik nu twee bits die per ongeluk door het
geheugen van 0 naar
1 waren veranderd.
Als ik naar mijn pariteit kijk, wordt het nog steeds een
1, want als ik die optel en het is een oneven getal, wordt
het een 1 voor mijn pariteitsbit.
En als ik die optel en het is een even getal,
dan wordt het een 0.
Dus zoals je kunt zien, zul je
niet in staat zijn om een fout te
detecteren als hierbinnen twee bits zijn veranderd
als je een pariteitstype berekening gebruikt.
Het goede nieuws is dat ongeveer 90% van de meeste fouten een fout
van het type enkele bit zal zijn, zodat pariteitscontrole
meestal voldoende is voor de meeste van onze
situaties.
Maar als je te maken hebt met iets als het
draaien van servers voor een bank, kunnen fouten
van welke aard dan ook een slechte zaak zijn.
We willen dus iets beters dan pariteit
en dat is waar ECC om de hoek komt kijken.
ECC staat nu voor Error Correcting Code.
Een foutcorrigerende code is het type geheugen
dat pariteit naar een hoger niveau tilt.
Nu kan het niet alleen een fout detecteren,
net zoals pariteit dat kan,
maar het kan die fout ook voor je corrigeren.
ECC is iets langzamer dan pariteit, wat ook
langzamer is dan niet-pariteit.
En dus lever je wat prestaties
in voor deze extra mogelijkheid,
maar je krijgt een hogere integriteit
en betrouwbaarheid van je geheugen
als je ECC gebruikt, omdat het
die fouten kan detecteren en herstellen.
Over het algemeen zie je ECC of foutcorrigerende
code alleen gebruikt worden
in echt high-end werkstations of servers vanwege de
extra kosten en dat extra hoge
integriteitsniveau is alleen nodig in
dat soort omgevingen.
Nu vraag je je misschien
af: hoe bepaalt ECC eigenlijk wat er mis was
en hoe het te repareren?
Om dat te doen, gebruikt
het iets dat bekend staat als gebufferd
of geregistreerd geheugen.
Gebufferd geheugen of geregistreerd
geheugen heeft extra hardware
tussen het geheugen en je CPU of processor.
Deze hardware wordt een register genoemd
en slaat gegevens op in een buffer
voordat ze naar de CPU worden gestuurd.
Deze functie wordt gebruikt als betrouwbaarheidsmaatregel
in veel systemen, vooral in systemen
zoals servers die veel verschillende
geheugenmodules hebben waar fouten kunnen
optreden.
Deze systemen vereisen buffering of registratie van de gegevens om
de elektrische belasting te verminderen
die wordt gebruikt door deze
systemen die grote hoeveelheden geheugenmodules hebben,
en dit kan worden gecombineerd met pariteitsgeheugen
of geheugen met foutcorrectiecode om je die
extra betrouwbaarheid te geven waar je naar op
zoek bent en die fouten te detecteren.
Om foutcorrigerende codemodules te kunnen gebruiken,
moet je moederbord dit ondersteunen, net als je CPU.
Als een van deze componenten ECC niet ondersteunt,
dan krijg je zelfs als je de ECC modules koopt die meer
kosten, niet dat extra ECC voordeel.
Houd daar dus rekening mee.
De meeste moederborden ondersteunen ECC of niet.
Over het algemeen is dat geen optie.
Dus als je een moederbord koopt dat ECC ondersteunt,
moet je ECC-modules kopen, dat zijn die
geregistreerde geheugenmodules.
Als je een moederbord vindt dat ECC- of niet-ECC-modules
ondersteunt, ondersteunen ze beide
modules meestal niet tegelijkertijd.
Dus al uw modules moeten ECC zijn of
geen van uw modules kan ECC zijn.
Als je er een mix van hebt, kan dat fouten veroorzaken in het systeem en
weet het moederbord niet hoe het ermee om moet gaan.
Het laatste dat ik wil
noemen is dat als je DDR5 gebruikt, DDR5
een aantal foutcontroles heeft die intern
in de modules zelf zitten.
Dit wordt niet beschouwd als ECC of een ECC-module.
En dus kan deze foutcorrectie
in de nieuwere DDR5-modules worden gebruikt op moederborden
die ECC niet ondersteunen en heb je nog steeds enige
foutcontrole mogelijkheid.
Dit is een andere vorm van foutcontrole
en wordt niet beschouwd als foutcorrigerende code.
Houd daar dus rekening mee en laat je niet in verwarring
brengen als je in het veld bent.
Dit is een andere vorm van foutcontrole
en DDR5-modules kunnen nog steeds worden
verkocht als ECC- of niet-ECC-modules, omdat ze
naast die interne foutcontrole ook kunnen samenwerken
met de CPU en het moederbord als die ECC ondersteunen
en ze nu ook foutcorrigerende code
hebben.
Ik weet dat het een beetje verwarrend wordt.
Wees je daar dus van bewust als je in het veld bent.