Paritetsfel i minnet upptäcks med en enkel paritetsbit. Så här fungerar det:
1. Paritetsbitberäkning: När data skrivs till minnet beräknas en paritetsbit för varje byte (eller ord, beroende på systemets arkitektur). Denna bit är inställd på antingen 0 eller 1 för att göra det totala antalet 1 i byte (inklusive paritetsbiten) antingen jämnt (till och med paritet) eller udda (udda paritet). Systemet använder konsekvent antingen jämn eller udda paritet.
2. Minneslagring: Paritetsbiten lagras tillsammans med databyten i minnet.
3. Paritetskontroll Läs: När data läses från minnet, beräknar systemet paritetsbiten baserat på de hämtade data.
4. Feldetektering: Denna omberäknade paritetsbit jämförs sedan med den lagrade paritetsbiten. Om de är olika upptäcks ett paritetsfel. Detta indikerar att minst en bit inom uppgifterna har vänt (ändrats från 0 till 1 eller vice versa).
Exempel (jämn paritet):
Låt oss säga att vi har Data Byte `10110100`.
* Antal 1s:4 (jämn)
* Even Parity Bit:0 (för att behålla det totala antalet 1s till och med)
* Lagras i minnet:`101101000`
Om lite vippar under lagring eller hämtning och vi läser `101101100`, skulle den omberäknade pariteten vara 1 (fem 1s), som inte matchar den lagrade paritetsbiten (0). Detta signalerar ett paritetsfel.
Begränsningar:
* Endast en-bit-feldetektering: Paritetskontroll kan bara upptäcka ett * udda * antal bitfel. Om två bitar vänder kommer pariteten fortfarande att vara korrekt, vilket resulterar i ett oupptäckt fel.
* felplats inte identifierad: Paritet upptäcker bara * närvaron * av ett fel, inte dess * plats * inom byten. Felkorrigering kräver mer sofistikerade tekniker som ECC (felkorrigeringskod).
Även om enkla, är paritetskontroll ett kostnadseffektivt sätt att upptäcka en betydande del av minnesfel, vilket gör det till ett gemensamt drag i många minnessystem. Mer robusta feldetekterings- och korrigeringsmetoder används där högre tillförlitlighet är avgörande (som i servrar och högpresterande datoranvändning).
