Fehlererkennung Rechnernetze 1einstein.informatik.uni-oldenburg.de/lehre/semester/... · 2012. 4....

Rechnernetze 1 Seite 1 Prof. Dr. W. Kowalk

Rechnernetze 1FehlererkennungFehlererkennung


Rechnernetze 1

FehlererkennungFehlererkennung

Datenübertragungüber physikalische Signalemehr oder minder hohe Anfälligkeit gegen Verfälschung der Signale

Empfänger interpretiert Signal anders als von Sender gemeint durch äußere Störeinflüsseinnere Unregelmäßigkeiten Zufall

beträchtliches Problem bei zuverlässiger Datenübertragung


Rechnernetze 1


Technische Systeme grundsätzlich nicht fehlerfrei Treten Fehler nur selten auf

innerhalb eines Rechensystemsin der Regel nicht berücksichtigt

Treten Fehler sehr häufig aufÜbertragung über stark gestörtes MediumMedium schwierig zu überprüfenFehler nicht vorhersehbar

angemessene Maßnahmen ergreifenRedundante ZusatzinformationGemeinsame BerechnungsvorschriftSender und Empfänger vergleichen ErgebnisFehlerhafte Daten korrigieren oder wiederholt senden


Rechnernetze 1


Was ist häufig?Wann ist Fehlererkennung/-korrektur notwendig?

Fehlerhäufigkeit quantitativ erfassenAuftreten von Fehlern möglichst sicher erkennen Angemessene Reaktion bei Fehlern → nächstes Kapitel

Keine absolute Sicherheit in realer Welt!heute

Korrigieren von Fehlern immer wichtiger


Rechnernetze 1


Entstehung von FehlernFehler in elektrischen Systemen

Empfänger eines Signals kann verschiedene Signalwerte nicht voneinander unterscheiden

Thermische Elektronenbewegung in Halbleitern/LeitungenElektromagnetische Einstrahlung

MotorenSpulen von ZündanlagenBlitze

Radioaktive EinstrahlungHöhenstrahlungnatürliche/künstliche Radioaktivität

Fehlerbündel (error burst)


Rechnernetze 1

FehlererkennungFehlererkennungEntstehung von Fehlern

beschränkte Übertragungskapazität einer Leitung Signal zu stark gedämpft

Dämpfung frequenzabhängigunglückliche Signalfolge kann Fehler erzeugenÜberlagerung mit anderen physikalischen Effekten

elektrische Charakteristika ändern sich kurzfristig nichtFehler meist nur sehr schwierig einzugrenzenSignalveränderungen treten selten und unregelmäßig aufeinfache technische Maßnahmen häufig nicht ausreichend

elektrische Abschirmungen


Rechnernetze 1


Entstehung von FehlernZufällige Fehler

Nicht vorhersehbarKaum berechenbarFühren nicht immer zu FehlernGeräte möglichst fehlerarm ausgelegt

Messungen von Fehlern an realen SystemEinfache mathematische Modelle


Rechnernetze 1


Fehlerbeschreibungstatistische Darstellung für Auftreten falscher Werteeinfaches Modell

unabhängige Fehlerwahrscheinlichkeit Wahrscheinlichkeit für falsches Bit unabhängig von 'Vorgeschichte' (Auftreten des letzten Fehler)realistisches Modell

zufällige Fehler treten nur einzeln aufnicht gerade Fehlerbursts

ein erkanntes Bit kann verfälscht, aber richtig seinim Mittel jedes zweite 'falsche' Bit hat richtigen Wert

Fehlererkennung von Fehlerbursts mit anderen Methoden


Rechnernetze 1

FehlererkennungFehlererkennungFehlerbeschreibung

Aufwändigere Modelle: Markov-Modelln Fehler in Folge im Zustand nkeine Fehler im Zustand 0Wahrscheinlichkeit zn, im Zustand n zu seinzn = p·zn-1 = pn·z0 = pn·(1-p)

Größere Anzahl von Bits einziehbarSehr geringe Fehlerwahrscheinlichkeiten


Rechnernetze 1


Fehlerhäufigkeit – BeispielSei Fehlerwahrscheinlichkeit ≈ 10-8

in Ethernet-Systemen im Mittel je Sekunde ein Fehler für praktische Anwendungen viel zu großer Wert

in fast jeder übertragenen Datei ein fehlerhaftes Bit Mehrfache Übertragung vergrößert Anzahl der Fehler schnell

Übertragungsfehler unbedingt erkennen und korrigieren!


Rechnernetze 1


Fehlerentdeckung durch RedundanzGrundlegende Methoden zur Fehlerentdeckung

fasse mehrere Bits in Blöcke zusammen fügen jedem Block ein oder mehrere Kontrollbits hinzu

Anzahl übertragener Bits größer als Nutzinformation Quantifizieren durch Redundanz relative zusätzliche Information zur Fehlererkennung

auch andere Definition (Informationstheorie) Zur Fehlerkorrektur mindestens zwei Verfahren

Falsche Blöcke werden noch einmal gesendet (ARQ)Fehlerkorrigierende Verfahren

Redundanz= Anzahl der übertragenen BitsAnzahl der Nutdatenbits

−1


Rechnernetze 1

FehlererkennungFehlererkennungFehlerentdeckung durch Redundanz

ARQ-VerfahrenSender kennt richtige Nachricht Sende Nachricht bei Fehler noch einmalÜbliches Verfahren in klassischen Anwendungen

Nicht geeignet beim Lesen von verfälschten DatenträgernFehlerkorrektur

Füge ausreichend Redundanz zur Nachricht hinzuWichtig bei stark fehlerhaften Kanälen

Drahtlose Kommunikation Bluetooth� → FEC (forward error correction)

Wichtig bei Speicherung von Datenfalsche Daten bleiben falschCD-Kodierung


Rechnernetze 1

FehlererkennungFehlererkennungBeispiel 1

Sende jeden Datenblock zweimal.Redundanz je Datenblock

Fehlerwahrscheinlichkeit je Datenblock

Jeden 10.000-sten Block zweimal sendenRedundanz für Datenübertragung:

R=21−1=1

P [mindestens ein Fehler in einem Block ]=

=1−1−10−71000≈ 110000,5

Redundanz= Anzahl der übertragenen BitsAnzahl der Nutdatenbits

−1=1,0001


Rechnernetze 1

FehlererkennungFehlererkennungBeispiel 2

Sende jeden Datenblock dreimal.Redundanz je Datenblock

Entscheider- oder Schiedsrichterverfahren (arbiter)Bei Fehler entscheidet 'Mehrheit'

FragestellungenWahrscheinlichkeit eines unerkannten Fehlers10-7000 bei zweimaligem Senden des Datenblocks

Kosten für FehlererkennungKosten bei Nichterkennung von FehlernAbhängigkeiten von Fehlerwahrscheinlichkeiten

R=31−1=2


Rechnernetze 1

FehlerkorrekturFehlerkorrektur

Hamming-Codesselbstkorrigierender Code (error correcting code)

Zusatzinformation um auftretende Fehler entdecken zugleich korrigieren

Hamming-CodesMathematiker Hamming (ca. 1950)

Verfahren zur Konstruktion eines Hamming-Codes


Rechnernetze 1

FehlerkorrekturFehlerkorrekturHamming-Codes

Information mit k Bits kodierbar Alphabet umfasst höchstens 2k verschiedene Zeichen

Zusätzlich r Bits Redundanz-Information wie viele Redundanz-Bits mindestens?

Fehler von s Bits in Nachricht erkennen und korrigieren im folgenden nur s=1 (ein 1-Bit-Fehler)

b1b2...bkp1p2..pr Codewort mit k Nutzdatenbit und r Prüfbit

Hamming-Abstand zwischen zwei CodewörternAnzahl von Stellen mit verschiedenen Bits

1 1 0 0 1 0 0 10 1 0 0 1 0 1 1/ = = = = = / = => Hamming-Abstand ist 2


Rechnernetze 1


Hamming-CodesHamming-Abstand eines Alphabets

minimaler Abstand zweier verschiedener Codewörter in diesem Alphabet

konstruiere fehler-korrigierenden Code zu Alphabet mit k Bit-Wörtern, d.h. 2k Wörtern


Rechnernetze 1


Hamming-CodesCodewort C der Länge n=k+r Bits

genau ein Codewort mit Hammingabstand 0 (C) zu C genau n Codewörter mit Hamming-Abstand 1

genau eines der n Bits von C komplementiert 2k Zeichen, jedes belegt n+1 Codewörter→ (n+1)·2k Codewörter mit n Bits darstellbar→ (n+1)·2k = (k+r+1)·2k ≤ 2n = 2k+r

→ k+r+1 ≤ 2r (Hamming-Bedingung)r Prüfbits zur Sicherung von k Datenbits


Rechnernetze 1

Hamming-CodesBeispiel

k=4, r=3: k+r+1=4+3+1=8 ≤ 2r=23 = 8. Regel ordne Prüfbit r (=1,2,3) Bits mit Nummer q zu, wenn in q r-tes Bit gesetzt ist.Ist Bit q falsch, so sind die Paritäten derPrüfgruppen {pi}=P falsch, wobei:

Auf längere Bitfolgen erweiterbar!Im Prinzip auch für 2-Bitfehler

Aufwand!


PrüfgruppenP P 1 2 31 001 12 010 13 011 1 14 100 15 101 1 16 110 1 17 111 1 1 1

Fehlerhaftes Bit Nr. 1 2 3 4 5 6 7Paritätsfehler in Gruppe(n) 1 2 1,2 3 1,3 2,3 1,2,3

q=∑i∈P

2i


Rechnernetze 1

Hamming-CodesBeispiel

k=4, r=3: k+r+1=4+3+1=8 ≤ 2r=23 = 8.


PrüfgruppenP P 1 2 31 001 12 010 13 011 1 14 100 15 101 1 16 110 1 17 111 1 1 1

Fehlerhaftes Bit Nr. 1 2 3 4 5 6 7Paritätsfehler in Gruppe(n) 1 2 1,2 3 1,3 2,3 1,2,3

1 2 3 4 5 6 7Gruppe 1 0 0 0 0 0 0 0Gruppe 2 0 0 0 0 0 0 0Gruppe 3 0 0 0 0 0 0 0

1 0000001 1 0 0 0 0 0 02 0000010 0 1 0 0 0 0 03 0000100 0 0 1 0 0 0 04 0001000 0 0 0 1 0 0 05 0010000 0 0 0 0 1 0 06 0100000 0 0 0 0 0 1 07 1000000 0 0 0 0 0 0 1


Rechnernetze 1


Korrektur von FehlerburstsBitfehlerfolgen maximalen Länge m korrigieren.

m Codewörter in einem Block zusammenfassenzunächst erste Bits der m Codewörter sodann zweite Bits übertragenusw.

Fehlerfolge nicht länger als mhöchstens ein Bit falschlässt sich natürlich korrigierenRedundanz sehr hoch


Rechnernetze 1


Korrektur von FehlerburstsRedundanz verringern durch Erhöhung der Bits je CodewortHöchstens ein Fehlerburst je Block!Im folgenden nurnoch Fehlererkennung(Ausnahme: CRC)


Rechnernetze 1


FehlerwahrscheinlichkeitenNutzdatenlänge k BitsÜbertragungsdatenlänge n BitsDifferenz r=n-k Länge der PrüfinformationRedundanz

Blockfehlerwahrscheinlichkeit Block der Länge n Bitfehlerwahrscheinlichkeit pgenau s fehlerhafte Bits bei Binomialverteilung

R= n−kk

ps=ns⋅ps⋅1− pn− s


Rechnernetze 1


BlockfehlerwahrscheinlichkeitBlocklänge nBitfehlerwahrscheinlichkeiten pBitfehler in Block s, mindestens ein Fehler im Block


Rechnernetze 1

FehlererkennungFehlererkennungBlockfehlerwahrscheinlichkeit 10-8

W. Bitfehler zu übersehen: 10-13 Blocklänge 128 Bits, wenn 1 Bitfehler erkennbarBlocklänge 1000 Bits, wenn 1+2 Bitfehler erkennbarBlocklänge 12000 Bits, wenn 1+2+3 Bitfehler erkennbar


Rechnernetze 1


mittlere Zeit bis zum nächsten Fehler mean time between error, MTBEBeispiel Ethernet

Blöcke mit 15000 Bits Länge10 MBit/s etwa 667 Blöcke je Sekunde jeder 8. falschmittlere Zeit zwischen zwei Fehlern ca. 12 msin jeder Sekunde über 80 Fehler

Mittlere Zeit zwischen zwei unentdeckten Fehlernmean time between undiscovered error, MTBUE


Rechnernetze 1

FehlererkennungFehlererkennungFehlererkennung mit einem, zwei, drei Bitfehlern

Wahrscheinlichkeit eines unentdeckten fehlerhaften Ethernetblocks maximaler Länge: 5,6·10-7.Zeit zwischen zwei unentdeckten fehlerhaften Blöcken ca. 10.000 Sekunden oder 3 StundenGroße FehlerwahrscheinlichkeitQualität erheblich verbessert


Rechnernetze 1


hier Überblick über Art von Fehlernvertretbare Wahrscheinlichkeiten für unentdeckte Fehlerin Praxis häufig Fehlern nicht unabhängig Fehler in Bündeln (burst)Entdeckung von Fehlerbursts gesondert behandelnnicht in jedem Fall ein realistischen ModellAnhaltspunkte für zu treffende Maßnahmen


Rechnernetze 1


Prüfsummen

Prüfinformation einfache algebraische Verfahren arithmetische Summe (i.d.R. modulo größerer Zahl) → Prüfinformationin IP und TCP eingesetzt

Unterschiedliche Art der AdditionEiner- oder Zweierkomplementzahlen Im Internet Einerkomplement-Verfahren


Rechnernetze 1


PrüfsummenZweierkomplementzahlen ohne Überlauf

Einfache Bitfehler werden mit Sicherheit erkanntZweifache Bitfehler werden nicht alle erkannt0100 + 0010 = 01101100 + 1010 = 10110Dreifache Bitfehler werden nicht alle erkannt0100 + 0010 + 0001 = 01111100 + 0110 + 0101 = 10111

Verfahren sehr schwach!


Rechnernetze 1

FehlererkennungFehlererkennungPrüfsummen

EinerkomplementzahlenIn IP (Header) TCP (Ganzer Datenblock)UDP (optional)

Einfache Bitfehler werden mit Sicherheit erkanntZweifache Bitfehler werden nicht alle erkannt0010 + 0001 = 00110000 + 0011 = 0011Dreifache Bitfehler werden nicht alle erkannt0011 + 0010 + 0000 = 01010001 + 0011 + 0001 = 0101

Verfahren sehr schwach!Sollte nach Prüfphase durch CRC ersetzt werden

Bis heute nicht geschehen


Rechnernetze 1


Paritätsprüfungsehr einfache Methode zur Fehlererkennung

ein Bit Prüfinformation Anzahl aller 1-Bits geradeauch: Summe modulo 2 ist 0auch: gerade Paritätalternativ: ungerade Parität

Prüfbit wird Paritätsbit genannt (parity bit)Redundanz 1/k

erkennt jede ungerade Anzahl von BitfehlernVerbesserungen

jeweils m<k Bits durch Paritätsbit prüfenjeweils jedes m-te Bit durch Paritätsbit prüfen


Rechnernetze 1


Paritätsprüfung von DatenblöckenVRC = Vertical Redundancy Check

Vertikale Redundanz-Prüfsumme' LRC = Longitudinal Redundancy Check

'longitudinale Prüfsumme'Redundanz

Jede ungerade Anzahl von BitfehlernZwei BitfehlerDie meisten geraden Bitfehler

VerwendungBlockprüfung bei magnetischen Datenträgern

X X X X X X X X PX X X X X X X X PX E X X E X X X PX X X X X X X X PX X X X X X X X PX E X X E X X X PX X X X X X X X PX X X X X X X X PP P P P P P P P

R= 2k


Rechnernetze 1


Zyklische Redundanzprüfung (CRC)

Cyclic Redundancy Check (CRC)Verallgemeinerung der ParitätsprüfungHeute allgemeine AnerkennungVielfache Einsatzmöglichkeiten

HDLC-LAPBLLCATMBluetooth


Rechnernetze 1



Darstellung einer Bitfolge als Polynom über Körper {+,·, {0,1}}Beispiel: 01611501401311201111009181716051403120110

Polynom: F(X) = X15+X12+X10+X8+X7+X6+X4+X2+1Körper {+,·; {0,1}}: 0+0=1+1=0, 1+0=0+1=1; 0·0=1·0=0·1=0; 1·1=1.Polynom-Rechenregeln ähnlich wie normale Rechenregeln. Jedoch:F(X)+F(X)=0


Rechnernetze 1

FehlererkennungFehlererkennungZyklische Redundanzprüfung (CRC)

BeispielDivisionbeimSender

Generator 1 0 1 0 1 1 RestDividend 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 0 0 0 0 0

1 0 1 0 1 10 0 0 1 0 1 1 0 0 0 1 1 0 1 1 0 0 0 0 0 0

1 0 1 0 1 10 0 0 1 1 1 0 1 1 0 1 1 0 0 0 0 0 0

1 0 1 0 1 10 1 0 0 0 0 0 1 1 0 0 0 0 0 0

1 0 1 0 1 10 0 1 0 1 1 1 1 0 0 0 0 0 0

1 0 1 0 1 10 0 0 1 0 0 0 0 0 0 0 0

1 0 1 0 1 10 0 1 0 1 1 0 0 0

1 0 1 0 1 10 0 0 1 1 1 0

Sende: 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0


Rechnernetze 1


BeispielDivision

Generator 1 0 1 0 1 1 RestDividend 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0

1 0 1 0 1 10 0 0 1 0 1 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0

1 0 1 0 1 10 0 0 1 1 1 0 1 1 0 1 1 0 0 1 1 1 0

1 0 1 0 1 10 1 0 0 0 0 0 1 1 0 0 1 1 1 0

1 0 1 0 1 10 0 1 0 1 1 1 1 0 0 1 1 1 0

1 0 1 0 1 10 0 0 1 0 0 0 0 1 1 1 0

1 0 1 0 1 10 0 1 0 1 0 1 1 0

1 0 1 0 1 10 0 0 0 0 0 0


Rechnernetze 1



Generatorpolynom G(X) vom Grad r.Nachricht U(X)Sender dividiert U(X)*Xr durch G(X) Rest D(X)U(X)*Xr = G(X)·Q(X) + D(X).Sender übermitteltU(X)��D(X)C(X) = U(X)·Xr + D(X) = G(X)·Q(X).Fehlerpolynom E(X): R(X) = C(X) + E(X).Empfänger dividiert R(X) durch G(X)Rest nicht null → Übertragungsfehler


Rechnernetze 1




Rechnernetze 1



1. Jedes Generatorpolynom erkennt genau ein falsches Bit

2. Jedes Generatorpolynom mit gerader Anzahl von Termen erkennt alle Fehler mit ungerader Anzahl fehlerhafter Bits

3. Jedes Generatorpolynom vom Grad r erkennt jeden Fehlerburst, dessen Länge nicht größer als r ist; bei Fehlerburst mit Länge r+1 alle Fehler bis auf einen

4. Jedes Generatorpolynom vom Grad r erkennt sämtliche 2-Bit-Fehler, die nicht in einem Vielfachen des Perioden-abstands des maximalen Generatorbitfilter zu G(X) liegen


Rechnernetze 1


Einige Generatorpolynome

CRC-16 und CRC-CCITT im wesentlichen gleich gutBitfilterlänge jeweils maximal (215-1=32767)Vielfach eingesetzt, z.B. HDLC-LAPBBlöcke bis zu 4095 Bytes optimal geschützt

CRC-33Ungerade Anzahl von Termen? Erkennt nicht (einmal) alle ungeraden Bitfehler?

CRC-16 CRC-CCITT

CRC-32 HEC

Bluetooth

X16+X15+X2+1X16+X12+X5+1X32+X26+X23+X22+X16+X12+X11+X10+X8+X7+X5+X4+X2+X+1X8+X2+X+1X5+X4+X2+1


Rechnernetze 1


FehlerkorrekturVerschiedene 1 Bit-Fehler erzeugen verschiedene Reste1 Bit- und 2 Bit-Fehler erzeugen verschiedene Reste

HEC (Header Error Correction)Im ATM-Standard: Fehlerhafter Header wird korrigiert

Bluetooth: 2/3 rate FEC15 Bit-Hammingverfahren: 10 Datenbits + 5 Bit Prüfsumme Generator = 110101Empfänger kann jeden einzelnen Bitfehler korrigierenEmpfänger kann allen zweifachen Bitfehler erkennen

HEC Bluetooth

X8+X2+X+1X5+X4+X2+1


Rechnernetze 1


Schieberegister mit Generator Q(X) = X16 + X15 + X2 + 1Einfaches Verfahren (on-the-fly)Gleiches Verfahren bei Sender und EmpfängerPreiswerte Hardware-Realisierung

Fehlererkennung Rechnernetze 1einstein.informatik.uni-oldenburg.de/lehre/semester/... · 2012. 4....

Documents

Transcript of Fehlererkennung Rechnernetze 1einstein.informatik.uni-oldenburg.de/lehre/semester/... · 2012. 4....