Beispiiel für einen Bitfehler

(1)

Grundlagen der Rechnernetze

Übertragungssicherung

(2)

Übersicht

• Fehlerdetektion

• Fehlerkorrektur Fehlerkorrektur

• Flusskontrolle

• Fehlerkontrolle

• Framing

Grundlagen der Rechnernetze ‐Übertragungssicherung 2

SS 2012

(3)

Fehlerdetektion

(4)

Ablauf der Fehlerdetektion

check bits

Bildquelle: William Stallings, „Data and Computer Communications“, 2004 SS 2012

(5)

Parity‐Check

1110001

Daten

1110001

Sender

Beispiiel für einen Bitfehler

Empfänger

1110001 1110001 1110001

(6)

Checksumme

1011 0101 1110 1001 ... 1100

^Sum(b₁^, b₂^, … , b_n⁾

b₁ b₂ b₃ b₄ b_n

Beispiel Summenberechnung anhand von Einer‐Komplement‐Arithmetik:

Beispiel Summenberechnung anhand von Einer Komplement Arithmetik:

SS 2012

(7)

Fehlerdetektion

C li R d d Ch k

Cyclic‐Redanduncy‐Check

(8)

Modulo 2 Arithmetik

A B A ⊕ B A B A ª B A B A B

Addition Modulo 2 Subtraktion Modulo 2 Multiplikation Modulo 2

A B A ⊕ B 0 0

A B A ª B 0 0

A B A · B 0 0

0 1 1 0

0 1 1 0 1 0

1 1

1 0 1 1

Beispiel 0110111011

⊕ 1101010110

=

SS 2012

(9)

Division Modulo 2

1010111 : 1101 = ????

Also: 1010111 : 1101 = Rest

(10)

CRC Idee

1010010000 : 1101

SS 2012

(11)

Cyclic‐Redundancy‐Check (CRC)

n‐k Nullen an Datenblock D anhängen:

1010001101

n‐Bit‐Frame T

01110

k‐Bit‐Datenblock D (n‐k)‐Bit‐FCS F

110101

Bestimmen von FCS F: (n‐k+1)‐Pattern P

T ist immer durch P teilbar:

Zu versendender Frame T:

(12)

Auswirkung von Fehlern

1010001101 01110

Sender T

E

1000011101 01011

T

_r

Empfänger

Ein Fehler mit nicht teilbarem Fehler‐Pattern wird erkannt:

SS 2012

(13)

CRC mit Polynomen

Darstellung von Datenblock und Pattern als Polynom:

110011

k‐Bit Datenblock D

Datenblock um n k Stellen (also hier 4 Stellen) verschieben:

11001

(n‐k+1)‐Pattern P Datenblock um n‐k Stellen (also hier 4 Stellen) verschieben:

Berechnung der FCS:

Darstellung des zu versendenden Frames Tg

(14)

Polynom‐Division Modulo 2

X

⁶

+ X

⁴

+ X

²

+ X

¹

+ 1 : X

³

+ X

²

+ 1 =

SS 2012

(15)

Auswirkung von Fehlern

10100

Sender T

00101

E

10001

T

_r

Empfänger

Für Generator P(X) und T(X)/P(X) = Q(X) werden nicht teilbare Fehler‐Pattern erkannt:

(16)

Erkennbare und nicht erkennbare Fehler

Ein Fehler ist nicht erkennbar genau dann wenn:

Single‐Bitfehler ist immer erkennbar, wenn P(X) mindestens zwei Terme enthält

Bitfehler‐Burst < Anzahl Check‐Bits ist immer erkennbar, wenn P(X) den Term 1 enthält

SS 2012

(17)

Weitere CRC‐Fakten

Double‐Bitfehler immer erkennbar, wenn P(X) einen Faktor mit drei Termen besitzt (ohne Beweis)

Ungeradzahlige Bitfehler immer erkennbar, solange P(X) einen Faktor (X+1) enthält (ohne Beweis)

Einen Anteil von 1‐2

^{‐(n‐k‐1)}

Fehler‐Bursts der Länge n – k + 1 (ohne Beweis) Einen Anteil von 1‐2

^{–(n – k)}

Fehler‐Bursts der Länge > n – k + 1 (ohne Beweis) Beliebte Polynome

CRC‐12 = X

¹²

+ X

¹¹

+ X

³

+ X

²

+ 1

16 15 2

CRC‐16 = X

¹⁶

+ X

¹⁵

+ X

²

+ 1 CRC‐CCITT = X

¹⁶

+ X

¹²

+ X

⁵

+ 1

CRC‐32 = X

³²

+ X

²⁶

+ X

²³

+ X

²²

+ X

¹⁶

+ X

¹²

+ X

¹¹

+ X

¹⁰

+ X

⁸

+ X

⁷

+ X

⁵

+ X

⁴

+ X

²

+ X + 1

(18)

Fehlerkorrektur

SS 2012

(19)

Ablauf der Fehlerkorrektur

Bildquelle: William Stallings, „Data and Computer Communications“, 2004

(20)

Beispiel Two‐Dimensional‐Parity

0 1 0 1 1 1 1 0 0 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1

SS 2012

(21)

Erkenn‐ und Korrigierbarkeit von Fehlern

0 1 0 1 0 0 1 0 1 0

Ein‐Bit‐Fehler immer korrigierbar Zwei‐Bit‐Fehler nicht immer korrigierbar

1 1 1 0 1 0 1 1 0 0

1 1 1 0 1 0 1 1 0 0 1 0 0 1 0

0 1 0 0 1

1 0 0 1 0 0 1 0 0 1

0 1 0 1 0 0 1 0 1 0

Zwei‐Bit‐Fehler immer erkennbar Nicht‐erkennbarer Fehler

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 0 1 1 0 0

1 0 0 1 0

0 1 1 0 0 1 0 0 1 0

0 1 0 0 1 0 1 0 0 1

(22)

Hamming‐Distanz

Hamming‐Distanz d(v₁, v₂) zwischen zwei n‐Bit‐Sequenzen v₁ und v₂

Beispiel: vier 4‐Bit‐Sequenzen mit einer paarweisen Hamming‐Distanz von

Wieviele Bit‐Fehler können erkannt werden?

mindestens 2

SS 2012

(23)

Block‐Codes

Allgemein:

Datenblock Codewort

00 00000

Sender

f : Datenblock

^

Codewort

Ablauf der Übertragung im Falle keiner Bitfehler 00 -> 00000

01 -> 00111 10 -> 11001

a e b oc ode o

11 -> 11110

Empfänger

Erkennen von Bit‐Fehlern: Es sei Code = {b₁,...,b_k} und es werde b empfangen:

(24)

Korrigieren von Bitfehlern

Empfangen Nächstes gültiges CW Daten

Datenblock Codewort

00 00000

00 -> 00000 01 -> 00111 10 -> 11001 11 -> 11110

Korrigieren von Bit‐Fehlern: Es sei Code = {b

₁

,...,b

_k

} und es werde b empfangen:

SS 2012

(25)

Für k Daten‐Bits und n‐Bit Code‐Wörter gilt

Eindeutiges C‐Wort für jeden D‐Block, also Benötigtes Verhältnis zwischen k und r=n‐

k zum Korrigieren von allen 1‐Bit‐Fehlern?

Benötigte Anzahl gültiger Code‐Wörter

Redundante Bits und Code‐Redundanz

Code‐Rate

Code‐Distanz für Code {b₁,...,b_k}

(26)

Hamming‐Code

1 2 3 4 5 6 7 8 9 10 11

Daten‐Bits Check‐Bits

3 = 0 0 1 1

Beispiel‐Daten‐Bits:

5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1

Beispiel Daten Bits:

1 0 0 1 0 0 0

7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

SS 2012

(27)

Erkennen eines Ein‐Bit‐Fehlers

0 0 1 1 0 0 1

1 2 3 4 5 6 7 8 9 10 11

0 0 0 0

Original

Code‐Wort Daten‐Bits

0 0 1 1 0 1 1 0 0 0 0

Ein‐Bit‐Fehler

Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0

Check Ergebnis

7 = 0 1 1 1

9 = 1 0 0 1

10 = 1 0 1 0

11 = 1 0 1 1

(28)

Hamming‐Code erreicht die Schranke

Wie eben für k Daten‐Bits und n‐Bit Code‐Wörter ausgerechnet:

Benötigtes Verhältnis zwischen k und r=n‐k zum Korrigieren von allen 1‐Bit‐

Fehlern:

r+k+1 ^· 2 ^r

Beispiel für unten abgebildeten Hamming‐Code: Was wenn Daten nur bis 11?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Daten‐Bits

Check‐Bits

SS 2012

(29)

Umgang mit Bit‐Fehler‐Bursts

Also:

Bildquelle: Andrew S. Tanenbaum, „Computer Networks“, Fourth Edition, 2003

(30)

Fakten zu allgemeinen Block‐Codes

Code‐Distanz von d_min ≥ 2t+1 kann bis zu wie viele c‐Bit‐Fehler korrigieren?

Also: Code‐Distanz von d_minerlaubt Korrektur von bis zu wie vielen Fehlern?

Und wie viele d‐Bit‐Fehler erkennen? Und Erkennen von wie vielen Fehlern?

SS 2012

(31)

Coding‐Gain

coding gain

(32)

Flusskontrolle

SS 2012

(33)

Stop‐and‐Wait

Es sei t_p der Propagation‐Delay und t_fdie Transmission‐Time für einen Frame. Die Gesamtzeit T für n Frames ist:

Die Utilization U (d.h. Zeit für Daten in

Relation zur Zeit für Daten plus Overhead) ist:

Definiere a = t_p / t_f(d.h. normalisiere t_f auf 1), dann ist:

(34)

Utilization in Abhängigkeit von a

1 Mbps Satelliten‐Link und 1000 Bit Frame mit 100ms Propagation‐

Bit Frame mit 100ms Propagation‐

Delay:

tionUtilizat

a = Propagation‐Delay / Transmission‐Time

SS 2012

(35)

Sliding‐Window‐Protokoll

Window

Sender Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6

…

F 1 F 2 F 3 F 4 F 5 F 6

Empfänger Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6

…

(36)

Sliding‐Window‐Protokoll: Details

(37)

Sliding‐Window‐Protokoll: Beispiel

(38)

Sliding‐Window‐Protokoll: Weitere Details

Bidirektionale Kommunikation, Piggibacking

A send Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6 ^Frame 7

…

A receive Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6 ^Frame 7

…

B receive Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6 ^Frame 7

…

B send Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6 Frame 7

…

B send Frame 1 Frame 2 Frame 3 Frame 4 Frame 5 Frame 6 Frame 7

…

SS 2012

(39)

Utilization – Fall 1: W ≥ 2a + 1

Fenstergröße = W, Frame‐Transmission‐Time = 1 und normalisierter Propagation‐Delay = a (a sei ganzzahlig). Was ist die Utilization U in diesem Fall?

(40)

Utilization – Fall 2: W < 2a + 1

Was ist die Utilization U in diesem Fall?

(41)

Utilitzation

Erinnerung: Satelliten‐

Link‐Beispiel: a = 100

zationUtiliz

(42)

Zusammenhang zum Delay‐Bandbreiten‐Produkt

Es sei a = Propagation‐Delay / Transmission‐Time

t

_p

= Propagation‐Delay [s]

t

_f

= Transmission‐Time [s]

B = Bandbreite [bps]

L = Frame‐Länge [Bits]

SS 2012

(43)

Fehlerkontrolle

(44)

Automatic‐Repeat‐Request (ARQ)

Fehlerdetektion

Positive‐Acknowledgment

Retransmission nach Timeout

Negative‐Acknowledgment und Negative Acknowledgment und

Retransmission

Fehlerfälle Techniken

(45)

Stop‐and‐Wait ARQ

(A) Lost/Damaged Frame (B) Lost ACK

(46)

Utilization von Stop‐and‐Wait ARQ

Es sei p Paket‐Fehlerrate. Was ist die erwartete Anzahl N der Übertragungsversuche?

Es sei t_p der Propagation‐Delay und t_f die Transmission‐Time. Was ist die Utilization U?

Mit a = Transmission‐Time/Propagation‐Delay erhält man:

SS 2012

(47)

Utilization in Abhängigkeit von a

Erinnerung: Satelliten‐

Link‐Beispiel: a = 100 p=10^‐2

p=10^‐3

Link Beispiel: a = 100 p=10^‐1

tionUtilizat

(48)

Go‐Back‐N ARQ

Fall: Frame(i) ist Damaged oder Lost:

B macht nichts

1. Fall: A sendet Frame(i+1)

B empfängt Out-of-Order Frame(i+1) B sendet REJ(i)

A muss Frame(i) und nachfolgende reübertragen

2. Fall: A sendet zunächst nicht Timer von A läuft ab

A sendet RR( mit P Bit=1“) A sendet RR(„mit P-Bit=1“) B muss mit RR(i) antworten

A sendet bei Empfang von RR(i) (Alternative zu Fall 2: A sendet

Frame(i) nach Ablauf des Timers)

(49)

Go‐Back‐N ARQ

Fall: Frame(i) ist Damaged oder Lost:

B macht nichts

1. Fall: A sendet Frame(i+1)

B empfängt Out-of-Order Frame(i+1) B sendet REJ(i)

A muss Frame(i) und nachfolgende reübertragen

2. Fall: A sendet zunächst nicht Timer von A läuft ab

A sendet RR( mit P Bit=1“)

Timeout

A sendet RR(„mit P-Bit=1“) B muss mit RR(i) antworten

A sendet bei Empfang von RR(i) (Alternative zu Fall 2: A sendet

Frame(i) nach Ablauf des Timers)

(50)

Go‐Back‐N ARQ

Fall: RR(i) ist Damaged oder Lost:

1. Fall: A empfängt ein späteres RR(j) (ACK sind kummulativ)

A weiß, dass Frame(i),...,Frame(j-1) korrekt angekommen sind

A macht weiter wie bisher 2. Fall: Timer von A läuft ab

A ht i d h lt

A versucht wiederholt:

(mit einem P-Bit-Timer)

A sendet RR(„mit P-Bit=1“) B muss mit RR(i) antworten B muss mit RR(i) antworten

Wenn nach einigen Versuchen keine Antwort, dann startet A eine Reset-Prozedur

Reset Prozedur

(51)

Go‐Back‐N ARQ

Fall: RR(i) ist Damaged oder Lost:

1. Fall: A empfängt ein späteres RR(j) (ACK sind kummulativ)

A weiß, dass Frame(i),...,Frame(j-1) korrekt angekommen sind

A macht weiter wie bisher 2. Fall: Timer von A läuft ab

A ht i d h lt

A versucht wiederholt:

(mit einem P-Bit-Timer)

A sendet RR(„mit P-Bit=1“) B muss mit RR(i) antworten B muss mit RR(i) antworten

Wenn nach einigen Versuchen keine Antwort, dann startet A eine Reset-Prozedur

Reset Prozedur

(52)

Go‐Back‐N ARQ

Fall: REJ ist Damaged oder Lost:

Timer von A läuft ab

A sendet RR(„mit P-Bit=1“)

B muss mit RR(i) oder REJ antworten A sendet bei Empfang von RR(i)

Timeout

*

(53)

Maximal erlaubte Window‐Größe?

A

Sequenznummergröße sei 3 Bits; Annahme wir nutzen die volle Window‐Größe 8

B

A

* * * * * * *

B Piggybacked ACK in

Übertragung von B nach A

Damit ist für k Bit Sequenznummern die maximal erlaubte Window‐Größe s : Damit ist für k Bit Sequenznummern die maximal erlaubte Window‐Größe s_max:

(54)

Selective‐Reject ARQ

Reübertragung von Frames Reübertragung von Frames

Reübertragung von Frames mit negative ACK

Reübertragung von Frames mit Timeout

SS 2012

(55)

Verwendung der Window‐Größe 2 ^k ‐1?

A

B

*

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 … Window von B

A

Timeout

*

B

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

Window von B 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 … Window von B

(56)

Maximal erlaubte Window‐Größe?

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 … Sender‐Fenster

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 … Empfänger‐Fenster

Problem: Sender‐Fenster und Empfänger‐Fenster überlappen (d.h. haben gemeinsame Sequenznummern) Lösung: mache Fenster kleiner, so dass keine Überlappungen vorhanden sind.

Also, damit ist für k Bit Sequenznummern die maximal erlaubte Window‐Größe s_max:

SS 2012

(57)

Utilization von Go‐Back‐N und Selective‐Reject

Allgemeine Beobachtung:

U

= Utilization eines Verfahrens ohne berücksichtigung Paket‐Verluste

U

Utilization eines Verfahrens ohne berücksichtigung Paket Verluste

U_e

= Utilization eines Verfahrens mit Berücksichtigung von Paket‐Verlusten

t

= Transmission‐Time für ein Paket

t_f

= Transmission‐Time für ein Paket

t_o

= gesamt benötigte Zeit für eine Paketübertragung (d.h. inklusive Delays)

A hl üb t P k t

n

= Anzahl übertragener Pakete

k

= Erwartete Anzahl an Paket‐Wiederholungen pro Paket bis zum Erfolgsfall

Es gilt:

(58)

Utilization bei Selective‐Reject ARQ

Wir hatten für Sliding‐Window ohne Fehler die Utilization U schon hergeleitet:

(mit W = Fenstergröße, a = Propagation‐Delay / Transmission‐Delay)

Wir hatten für Paket‐Fehlerrate p die erwartete Anzahl k der Übertragungsversuche schon hergeleitet:

Mit voriger Beobachtung erhält man für a = Transmission‐Time/Propagation‐Delay und U_e = Utilization mit Berücksichtigung von Paket‐Verlusten:

Utilization mit Berücksichtigung von Paket‐Verlusten:

SS 2012

(59)

Utilization bei Go‐Back‐N ARQ

Wir hatten für Sliding‐Window ohne Fehler die Utilization Uschon hergeleitet:

Es sei m die Anzahl zu übertragender Frames, wenn ein Frame reübertragen werden muss.

E i di P k f hl

(mit W = Fenstergröße, a = Propagation‐Delay / Transmission‐Delay) Es sei p die Paketfehlerrate.

1.) Gesamtanzahl Reübertragungen f(i), wenn ein Frame iVersuche brauchte:

2.) Erwartete Gesamtanzahl k an Reübertragungen für ein Frame:

3.) Somit ergibt sich mit voriger Beobachtung für a = Transmission‐Time/Propagation‐Delay und U_e = Utilization mit Berücksichtigung von Paket‐Verlusten:

(60)

Utilization bei Go‐Back‐N ARQ

m für W ≥ 2a + 1:

Also, gemäß voriger Folie:

SS 2012

(61)

Utilization bei Go‐Back‐N ARQ

m für W < 2a + 1:

Also, gemäß voriger Folie:

(62)

Vergleich für p=10 ^‐3

Erinnerung: Satelliten‐g Link‐Beispiel: a = 100

izationUtili

SS 2012

(63)

Framing

(64)

Problemstellung

Upper Layers Upper Layers

Frame 1 Frame 2 Frame 3 Frame 4

Link‐Layer Link‐Layer

100010110111011011011101 100010110111011011011101…

Physical Layer Physical Layer

SS 2012

(65)

Asynchrone Übertragung

(66)

Framing

S h Üb t itt l Ch t C t B t d Bit St ffi

Synchrone Übertragung mittels Character‐Count, Byte‐ und Bit‐Stuffing

SS 2012

(67)

Character‐Count

Beispiel für Character‐Count‐Verfahren ohne Übertragungsfehler

Beispiel für Fehler bei Character‐Count‐Verfahren aufgrund von Übertragungsfehler

(68)

Flag‐Bytes und Byte‐Stuffing

Bildquelle: Andrew S. Tanenbaum, „Computer Networks“, Fourth Edition, 2003 SS 2012

(69)

Start‐ und End‐Flags mit Bit‐Stuffing

Frames beginnen und enden mit speziellem Bit‐Pattern: z.B. 01111110

01111110 | H d | P l d | T il | 01111110 01111110 | Header | Payload | Trailer | 01111110

(70)

Framing

B i i l fü h Üb t itt l E di Vi l ti Beispiel für synchrone Übertragung mittels Enoding‐Violations

SS 2012

(71)

Erinnerung: NRZ und das Clocking‐Problem

Sender

00111010101000000000000000000000000000000000000000000 Daten

Signal Sender

Empfänger

Zeit

Sampling p g

Clock Drift Zeit Clock Synchronization Clock‐Drift Clock‐Synchronization

Bildquelle: William Stallings, „Data and Computer Communications“, Seventh Edition, 2004

(72)

4B/5B

Data 5‐Bit‐Code Data 5 Bit Code 0000 11110 0001 01001

...

0010 10100 0011 10101 0100 01010 0101 01011 0110 01110 0111 01111 1000 10010 1001 10011 1010 10110 1011 10111 1100 11010 1100 11010 1101 11011 1110 11100

1111 11101

SS 2012

(73)

Zusammenfassung und Literatur

(74)

Zusammenfassung

• Behandlung von Fehlern bei der Bitübertragung

– Fehlerdetektion versus Vorwärtsfehlerkorrektur Fehlerdetektion versus Vorwärtsfehlerkorrektur – Hamming‐Distanz

T d ff i h C d Lä d R d d

– Tradeoff zwischen Code‐Länge und Redundanz – Fehlerkontrolle

• Behandlung von Synchronisationsfehlern

– Flusskontrolle – Flusskontrolle – Framing

SS 2012

(75)

Literatur

[S lli 2004] Willi S lli D d C C i i “

[Stallings2004] William Stallings, „Data and Computer Communications“, Seventh Edition, 2004.

6.1 Asynchronous and Synchronous Transmission 6.3 Error Detection

6.4 Error Correction 7.1 Flow Control 7.2 Error Control

7.A Performance Issues

[Tanenbaum2003] Andrew S Tanenbaum Computer Networks“ Fourth [Tanenbaum2003] Andrew S. Tanenbaum, „Computer Networks , Fourth

Edition, 2003.

3.1.2 Framing

3 2 1 Error‐Correcting Codes 3.2.1 Error‐Correcting Codes 3.2.2 Error‐Detecting Codes

[PetersonDavie2007] Larry L. Peterson and Bruce S. Davie, „Computer Networks: A Systems Approach“ Edition 4 Morgan Kaufmann 2007 Networks: A Systems Approach , Edition 4, Morgan Kaufmann, 2007.