Reti di Calcolatori, A.A. 2005/06 M. Cesati / E.

Betti

Reti di calcolatori

Lezione 7
Lez. 7 — 1 M. Cesati / E. Betti

Il modello di riferimento

5 Application
4 Transport
3 Network
2 Data Link
1 Fisico
Lez. 7 — 2 M. Cesati / E. Betti

Tx: messaggio M Trasmissione

+ bit di controllo R Q
Q

 Rx: parola C0
= parola di codice C

J
J

J
J

@
@ @
@ @
@ @
@ @
SI NO C0 è parola @@ NO
@ @

C0 == C ?
@
@ @ Q
Q
 Errore rilevato
di codice?
@ @ 
@ @
@ @
@ @
@ @
@ @
@
@ @
@

SI
J
J
J

J
J
J

Nessun Errore non

Rx OK
errore rilevato
Lez. 7 — 3 M. Cesati / E. Betti

Codice di Hamming (1)

Il codice di Hamming (1950) è un particolare codice a correzione d’errore:

• Consente di correggere 1 singolo errore

• Ha un numero di bit di controllo pari al limite teorico inferiore

(2m · (n + 1) ≤ 2n, n = m + r ⇒ m ≤ 2r − r − 1)

• Funziona con qualunque dimensione del messaggio m

Lez. 7 — 4 M. Cesati / E. Betti

Codice di Hamming (2)

• I bit della parola di codice vengono numerati da sinistra verso destra e comin-
ciando con l’indice 1

• I bit di controllo sono quelli aventi come indice una potenza di due
(1, 2, 4, 8, 16, . . . )

• I bit del messaggio sono tutti gli altri bit della parola di codice, nell’ordine

• il bit di controllo con indice 2k è il bit di parità dei bit del messaggio i cui indici
hanno il termine 2k nella loro scomposizione in somma di potenze di due
Lez. 7 — 5 M. Cesati / E. Betti

Codice di Hamming (3)

In ricezione, ciascun bit di controllo viene ricalcolato:

• Se tutti i valori dei bit di controllo sono corretti, la parola di codice viene accettata

• Se alcuni bit di controllo hanno valori non corretti, l’indice del bit in cui si è ve-
rificato l’errore è dato dalla somma degli indici dei bit di controllo con valore
sbagliato
Lez. 7 — 6 M. Cesati / E. Betti

Codice di Hamming – Esempio (1)

Consideriamo il seguente messaggio (m = 12):

010110011010

I bit di messaggio della parola di codice sono i seguenti:

r1 r2 0 r3 1 0 1 r4 1 0 0 1 1 0 1 r5 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Lez. 7 — 7 M. Cesati / E. Betti

Codice di Hamming – Esempio (2)

Il bit di parità r1 controlla i bit con indice dispari:

r1 r2
0 r3
1 0
1 r4
1 0
0 1
1 0
1 r5
0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Poiché i relativi bit “1” del messaggio sono in numero dispari:

1 r2
0 r3
1 0
1 r4
1 0
0 1
1 0
1 r5
0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Lez. 7 — 8 M. Cesati / E. Betti

Codice di Hamming – Esempio (3)

Il bit di parità r2 controlla i bit con indice la cui scomposizione in binario include 21
(3=2+1, 6=4+2, 7=4+2+1, 10=8+2, 11=8+2+1, . . . )

r1 r2
0 r3 1
0
1 r4 1
0
0 1 1
0
1 r5 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Poiché i relativi bit “1” del messaggio sono in numero pari:

r1
0
0 r3 1
0
1 r4 1
0
0 1 1
0
1 r5 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Lez. 7 — 9 M. Cesati / E. Betti

Codice di Hamming – Esempio (4)

Il bit di parità r3 controlla i bit con indice la cui scomposizione in binario include 22
(5=4+1, 6=4+2, 7=4+2+1, 12=8+4, 13=8+4+1, . . . )

r1 r2 0 r3
1
0
1 r4 1 0 0
1
1
0
1 r5 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Poiché i relativi bit “1” del messaggio sono in numero dispari:

r1 r2 0
1
1
0
1 r4 1 0 0
1
1
0
1 r5 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Lez. 7 — 10 M. Cesati / E. Betti

Codice di Hamming – Esempio (5)

Il bit di parità r4 controlla i bit con indice la cui scomposizione in binario include 23
(9=8+1, 10=8+2, 11=8+2+1, 12=8+4, 13=8+4+1, . . . )

r1 r2 0 r3 1 0 1 r4
1
0
0
1
1
0
1 r5 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Poiché i relativi bit “1” del messaggio sono in numero pari:

r1 r2 0 r3 1 0 1
0
1
0
0
1
1
0
1 r5 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Lez. 7 — 11 M. Cesati / E. Betti

Codice di Hamming – Esempio (6)

Il bit di parità r5 controlla i bit con indice la cui scomposizione in binario include 24
(17=16+1)

r1 r2 0 r3 1 0 1 r4 1 0 0 1 1 0 1 r5
0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Poiché i relativi bit “1” del messaggio sono in numero pari:

r1 r2 0 r3 1 0 1 r4 1 0 0 1 1 0 1
0
0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Lez. 7 — 12 M. Cesati / E. Betti

Codice di Hamming – Esempio (7)

Il messaggio

010110011010

viene dunque codificato come:

10011010100110100
Lez. 7 — 13 M. Cesati / E. Betti

Codice di Hamming – Esempio (8)

Supponiamo che si verifichi un errore:

10011010110110100

Ricalcolando i bit di controllo si ottiene:

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

Sommando gli indici dei bit di controllo discordanti: 2 + 8 = 10

Lez. 7 — 14 M. Cesati / E. Betti

Codice di Hamming per burst di errori (1)

Il codice di Hamming corregge un singolo errore su stringhe di m bit

Supponiamo di voler invece correggere un burst di al più k errori (ma non tutti i k bit
sono necessariamente sbagliati!)

1. codificare k messaggi consecutivi di lunghezza m, ottenendo k parole di codice

di lunghezza n
2. organizzare le k parole di codice in una matrice
3. inviare i k bit della prima colonna, poi i k bit della seconda colonna, . . . , infine i
k bit della n-esima colonna

Se il burst di errori è lungo al più k, ciascuna riga della matrice può avere al più 1 bit
errato, quindi il codice è in grado di correggerlo
Lez. 7 — 15 M. Cesati / E. Betti

Codice di Hamming per burst di errori (2)

1 2 3 n

1 S 
S
S
2  S
S 
S
3
S
 S

##
S 
S
 SS

S %
S%
%% SS
S %
S%
% S
% S
e %
e%
% ee
%
e %
L  L  L  e% L 
L  L  L  L 
k L L L %% ee L
Lez. 7 — 16 M. Cesati / E. Betti

Codici per il rilevamento di errori

I codici per il rilevamento di errori sono in pratica più diffusi dei codici per la correzione
di errori:

• i codici per il rilevamento sono molto più efficienti dei codici per la correzione
(meno ridondanza nei bit trasmessi)

• se un codice per la correzione di 1 errore indica che un bit è errato, vi è una

probabilità non trascurabile che si sia verificato un intero burst di errori (gli errori
tendono ad addensarsi)
Lez. 7 — 17 M. Cesati / E. Betti

Bit di parità

Il più semplice codice per il rilevamento di errori è il bit di parità

Ha distanza di Hamming pari a 2, quindi garantisce solo il rilevamento del singolo

errore

Un solo bit di controllo è sufficiente per blocchi di qualunque dimensione

I burst di errori vengono rilevati solo quando il numero effettivo di bit sbagliati è
dispari, ossia con probabilità 50%
Lez. 7 — 18 M. Cesati / E. Betti

Bit di parità per burst di errori (1)

Un metodo per rilevare interi burst di al più k errori basato sul bit di parità è il
seguente:

1. distribuire i bit da trasmettere in una matrice con righe di k bit

2. per ciascuna colonna, calcolare il relativo bit di parità
3. inviare la prima riga, poi la seconda riga, eccetera
4. inviare come ultima riga i bit di controllo

Un burst di al più k errori è sempre rilevato, perché modifica al più un bit per ciascuna
colonna

La probabilità che un burst di p errori (p > k + 1) non venga rilevato è 1/2k

Lez. 7 — 19 M. Cesati / E. Betti

Bit di parità per burst di errori (2)

1 2 3 k
aa
a
!
!!
aa
a
!
!!
aa
a
!
!!

#l ,
# ,e ,,@ e %@ , ,l l %
l
, ,
e @ %
e @
, l l
%
, l, e @% e , @ l
l% ll
l ,e
,
l
,l e
, l e

aa
a
!
!!

A
A
A
A
A
A
A
A
A
A
A

aa
a
!
!!
Lez. 7 — 20 M. Cesati / E. Betti

Codice polinomiale
Il codice polinomiale, detto anche cyclic redundancy code (CRC), è il codice per il
rilevamento di errori più diffuso

In apparenza è complesso, ma esistono circuiti hardware abbastanza semplici che lo

calcolano efficientemente

È basato sulla teoria dei campi algebrici:

• le addizioni e sottrazioni sono sempre effettuate modulo 2 (XOR), quindi non

esiste riporto o prestito

• la divisione è effettuata come in binario ma con sottrazioni modulo 2; inoltre

un divisore “sta” nel dividendo se il dividendo ha tanti bit significativi quanti il
divisore, ossia se il resto ha strettamente meno bit significativi del divisore
Lez. 7 — 21 M. Cesati / E. Betti

Rappresentazione di polinomi con sequenze di bit

Il codice polinomiale è basato sulla rappresentazione di polinomi algebrici a coeffi-

cienti in {0, 1} con sequenze di bit

Una sequenza di k bit rappresenta un polinomio di grado (al più) k − 1; ciascun bit è
il valore di un coefficiente. Ad esempio:

10001001001

corrisponde al polinomio

x10 + x6 + x3 + 1
Lez. 7 — 22 M. Cesati / E. Betti

Polinomio generatore

Il polinomio generatore G(x) è un polinomio algebrico prefissato di grado r (la stringa

ha r + 1 bit). È conosciuto sia dal trasmittente che dal ricevente. Il primo e l’ultimo
bit devono essere “1”.

Il messaggio da trasmettere è rappresentato da un altro polinomio M (x) di grado al

più m − 1 (m > r)

Idea chiave: appendere al messaggio una stringa di bit di controllo in modo tale che
il polinomio corrispondente alla parola di codice sia divisibile per G(x)

Se uno o più errori di trasmissione modificano la parola di codice, il polinomio corri-

spondente non sarà divisibile, con altà probabilità, per G(x).
Lez. 7 — 23 M. Cesati / E. Betti

Algoritmo di calcolo del CRC

1. Aggiungere r bit “0” in coda agli m bit del messaggio (la nuova stringa rappre-
senta il polinomio xr M (x))
2. Dividere la stringa corrispondente a xr M (x) per la stringa corrispondente a
G(x)
3. Sottrarre il resto (che ha sempre al più r bit) dalla stringa corrispondente a
xr M (x)
4. Il risultato è il polinomio T (x) da trasmettere: è divisibile per G(x) ed i primi m
bit sono uguali a quelli di M (x)

Il polinomio T 0(x) ricevuto viene diviso per G(x): il messaggio viene accettato se e
solo se il resto della divisione è zero
Lez. 7 — 24 M. Cesati / E. Betti

Calcolo del CRC – Esempio (1)

Fissiamo il polinomio generatore: G(x) = x4 + x + 1 (corrispondente a 10011)

Sia il messaggio = 101101 (corrispondente a M (x) = x5 + x3 + x2 + 1)

Passo 1: aggiungiamo r = 4 bit “0” al messaggio: 1011010000

Passo 2: dividiamo x4M (x) per G(x): scartiamo il risultato e memorizziamo il resto
Lez. 7 — 25 M. Cesati / E. Betti

Calcolo del CRC – Esempio (2)

1 0 1 1 0 1 0 0 0 0 1 0 0 1 1
1 0 0 1 1 1
0 0 1 0 1 1 0
0 0 0 0 0
1 0 1 1 0 1
1 0 0 1 1
0 1 0 1 0 0
0 0 0 0 0
1 0 1 0 0 1
1 0 0 1 1
0 1 1 1 0 0
0 0 0 0 0
1 1 1 0 1 0 1 0 1 0
Lez. 7 — 26 M. Cesati / E. Betti

Calcolo del CRC – Esempio (3)

Passo 3: sottraiamo il resto della divisione da x4M (x):

1 0 1 1 0 1 0 0 0 0 -

1 1 1 0 =

1 0 1 1 0 1 1 1 1 0

La sequenza di bit da trasmettere è dunque:

1011011110
Lez. 7 — 27 M. Cesati / E. Betti

Errori catturati dal CRC (1)

Sia T (x) il polinomio trasmesso, e sia T (x) + E(x) il polinomio ricevuto

Ogni bit “1” in E(x) corrisponde ad un bit invertito per errore

T (x) + E(x) diviso G(x) ha resto zero se e solo se

E(x) è nullo (trasmissione senza errori), oppure

E(x) è un multiplo di G(x)

Lez. 7 — 28 M. Cesati / E. Betti

Errori catturati dal CRC (2)

Se G(x) ha due o più termini, il codice polimoniale rileva tutti gli errori singoli
(E(x) = xi non può essere multiplo di G(x), perché G(x) contiene sempre almeno
due termini)

Se G(x) non è divisibile per x e non divide alcun xk + 1, con k = 1, . . . , n, il codice

polinomiale rileva tutti gli errori in parole di codice da n bit consistenti in due bit
invertiti (per assurdo, se E(x) = xi + xj fosse multiplo di G(x), allora xj (xi−j + 1)
sarebbe uguale a G(x)P (x)xj in quanto G(x) non è divisibile per x, perciò xi−j +1
sarebbe uguale a G(x)P (x), ossia G(x) dividerebbe xk + 1)

Se G(x) ha come fattore x + 1, il codice polinomiale rileva tutti gli errori consistenti
di un numero dispari di bit (non esiste alcun polinomio con numero dispari di termini
che abbia x + 1 come fattore)
Lez. 7 — 29 M. Cesati / E. Betti

Errori catturati dal CRC (3)

Se G(x) ha grado r (r bit di controllo), il codice polinomiale rileva tutti i burst di al più
r errori

Infatti, un burst di k errori è rappresentato da

E(x) = xi(xk−1 + . . . + 1)

Dato che G(x) contiene il termine x0, G(x) non può avere xi come fattore;
se k − 1 < r, l’altro fattore di E(x) non può essere multiplo di G(x).
Perciò il resto di E(x)/G(x) non può essere nullo

Dato un burst di r + 1 errori, la probabilità che esso non sia rilevato è 1/2r−1; la
probabilità di non rilevare un burst di più di r + 1 errori è 1/2r (assumendo che
all’interno del burst gli errori si distribuiscano in modo casuale)
Lez. 7 — 30 M. Cesati / E. Betti

CRC standard (1)

Alcuni polinomi generatori sono diventati standard internazionali:

• CRC-8: x8 + x2 + x + 1 (usato in reti ATM)

• CRC-10: x10 + x9 + x5 + x4 + x + 1 (usato in reti ATM)

• CRC-12: x12 + x11 + x3 + x2 + x + 1 (usato per caratteri codificati con 6 bit)

• CRC-16: x16 + x15 + x2 + 1 (usato per caratteri ad 8 bit)

• CRC-CCITT: x16 + x12 + x5 + 1 (usato da HDLC)

• CRC-32: x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 +

x4 + x2 + x + 1 (usato in IEEE 802 e in reti ATM)
Lez. 7 — 31 M. Cesati / E. Betti

CRC standard (2)

Il codice a 32 bit CRC-32 rileva:

• tutti gli errori singoli e doppi

• tutti gli errori con numero dispari di bit
• tutti i burst di errori di lunghezza al più 32
• teoricamente, il 99.9999999% di tutti i burst di errori lunghi più di 32 bit

In realtà la stima teorica per i burst lunghi 33 o più bit è troppo ottimistica,
in quanto i bit erronei non sono distribuiti all’interno del burst in modo veramente
casuale