Error control coding

bloatdecorumΛογισμικό & κατασκευή λογ/κού

30 Οκτ 2013 (πριν από 3 χρόνια και 7 μήνες)

110 εμφανίσεις

Computer Networking

Error Control Coding





Dr Sandra I. Woolley





An Introduction to Error Control Coding


Data transmission and channel
errors


Introduction to error control


Parity


Hamming codes


example of a simple linear block
code


Interleaving and product codes


(+ demonstration).


IP checksums (Polynomial/Cyclic
Redundancy Codes)



We will work through examples in
class.


http://www.thinkgeek.com/interests/exclusives/7a5c/images/1293/

3

Introduction


Error control coding involves the addition of redundancy to
enable error detection and/or correction.



There are two basic approaches to error control


Automatic retransmission request (ARQ)


Forward error correction (FEC)



More generally, when errors are detected data can be resent,
concealed or corrected.

4

Data Transmission

Compress

Data

Encrypt

Error control

Line code

Channel

errors

Remove redundancy
for efficient
communication

Encrypt message
for added security

Add systematic
redundancy to protect
data against channel
errors

Encode signal to suit
communication
channel
characteristics

..011
101
10..

..01101010..

5

Designing Error Protection Systems


“Know your enemy”


Understand the channel burst length distribution and gap
length distribution, i.e., how large and how frequent are the
errors.


Trade
-
off the correction of data with the addition of redundancy


System cost/delay


Should errors be detected and corrected?


Detect and request retransmission? Detect and conceal?


How important is the data.


Is all data equally important? Should some data elements be
protected more than others?


Is accepting bad data as good worse than rejecting good data as
bad?


6

Channel Errors


Errors can occur singly or in bursts.


Most channel errors can be approximated by simple state models.


The BER (Byte error rate) is a simple measure of channel quality.










In the Good state there are no errors.


Bad Type 1 and Bad Type 2 represent two types of error events;
non
-
burst
and
burst
.


p1 and p2 are the probabilities of starting the errored states.


q1 and q2 are the probabilities of ending the errored states.


Good

Bad

Type 2

1
-
q2

p2

Bad

Type 1

1
-
q1

p1

1
-
p1
-
p2

The modified

Gilbert model

q1

q2

7

Channel Errors


Burst length distributions provide important information about
channel error activity.

Good

Bad

Type 2

1
-
q2

p2

Bad

Type 1

1
-
q1

p1

1
-
p1
-
p2

increasing p1

decreasing q1

increasing p2

decreasing q2

error length (log scale)

Probability (log scale)

q1

q2

The Simplest Error Detection


Parity Bit


Odd or even parity requires
that the sum total of
codewords be odd or even,
respectively.


So for odd parity there will be
an odd number of ones and
for even parity there will be an
even number of ones.


For example, if we have data
bits 0011010 and we want
even parity. We need to add
a parity bit of 1 to have an
even number on ones. So, if
we append our parity bit to the
end, we have a codeword of
0011010
1

(where
1

is our
even parity bit).




7 bits of data

(number of 1s)

8 bits including parity

even

odd

0000000 (0)

0
0000000

1
0000000

1010001 (3)

1
1010001

0
1010001

1101001 (4)

0
1101001

1
1101001

1111111 (7)

1
1111111

0
1111111

Examples from Wikipedia

The parity bit is added to the front

http://en.wikipedia.org/wiki/Parity_bit

9

The Hamming (7,4) Code


An example of an (
n,k
) linear block code. Each codeword contains n bits,
k information bits and (n
-
k) check bits.


The Hamming (7,4) is a nice easy code but it is not very efficient (it has a
75% overhead!). It generates
codewords

with a ‘Hamming distance’ of 3,
i.e., all
codewords

differ in 3 locations. It can correct one bit in error and
detect two.


In the codeword

[C]= k1 k2 k3 k4 c1 c2 c3
,


k1
-
k4

are information bits and
c1
-
c3
are check bits (the ‘systematic
redundancy’). “+” here denotes binary addition (it is the same as XOR).


c1=k1+k2+k4

c2=k1+k3+k4

c3=k2+k3+k4


So the data

[X] = [0 1 1 0]
becomes the codeword

[0 1 1 0 (0+1+0) (0+1+0) (1+1+0)] = [0 1 1 0 1 1 0]


10

The Hamming (7,4) Code


If we insert an error at bit 2

[ x ]
(syndrome)

[0 1 1 0 1 1 0]

becomes

[0 0 1 0 1 1 0]


Note
c1

and
c3

are

wrong
-

these intersect

at
k2

hence

k2

is in error

c1=k1+k2+k4

c3=k2+k3+k4

c2=k1+k3+k4

k1

k2

k4

k3

0

0

1

1

0

1

0

11

The Hamming (7,4) Code


If we insert an error at bit 4

[ x ]
(
syndrome
)

[0 1 1 0 1 1 0]

becomes

[0 1 1 1 1 1 0]


Note
c1
,
c2

and
c3


are all wrong

hence

k4

is in error


c1=k1+k2+k4

c3=k2+k3+k4

c2=k1+k3+k4

k1

k2

k4

k3

0

0

1

1

1

1

1

12

Bi
-
Directional/Product Codes


Imagine we have 4 x 4 data bits


k
1
1
-
k
1
4, k
2
1
-
k
2
4, k
3
1
-
k
3
4, k
4
1
-
k
4
4



Arranging them horizontally we can add error protection in the
vertical direction as well.



k
1
1 k
1
2 k
1
3 k
1
4
c
1
1 c
1
2 c
1
3


k
2
1 k
2
2 k
2
3 k
2
4
c
2
1 c
2
2 c
2
3


k
3
1 k
3
2 k
3
3 k
3
4
c
3
1 c
3
2 c
3
3


k
4
1 k
4
2 k
4
3 k
4
4
c
4
1 c
4
2 c
4
3


d
1
1 d
1
2 d
1
3 d
1
4 f
1
1 f
1
2 f
1
3


d
2
1 d
2
2 d
2
3 d
2
4 f
2
1 f
2
2 f
2
3


d
3
1 d
3
2 d
3
3 d
3
4 f
3
1 f
3
2 f
3
3


13

Bi
-
Directional/Product Codes


In the class we observe animated demonstrations of these codes
at work using the product code demonstrator.


First we generate errors using the Modified Gilbert Error
Model. The model requires just 4 probability values to
describe the errors it generates.


Next the data was interleaved.


Then the data was iteratively corrected vertically and
horizontally.


The demonstration shows how, with more sophisticated error
control coding, we can significantly increase correction capacity
making even severely corrupted data correctable.


The complex and time
-
consuming nature of this method makes it
inappropriate for Internet protocols*. However, robust correction
is desirable in storage systems and these methods can be found
in the more sophisticated server room RAID
-
type** storage
systems.

*but important payload data could be protected in this way

**RAID


Redundant Array of Inexpensive Disks


14

Interleaving

Interleaving (systematically reordering) the protected data stream means that
errors are distributed, i.e., more correctable.


For example, consider the three (7,4) Hamming
codewords

below in transmission
on a channel with a small burst of 3
errored

bits (syndrome
x
x

x
).


k1 k2 k3 k4 c1 c2 c3
k1 k2 k3 k4 c1 c2 c3

k1 k2 k3 k4 c1 c2 c3


x
x

x


These 3 bits all fall in one codeword, so would be
uncorrectable
.


But with a three
-
way interleave:
-

k1
k1

k1

k2
k2

k2

k3
k3

k3

k4
k4

k4

c1
c1

c1

c2
c2

c2

c3
c3

c3


x
x

x


Assuming the same syndrome of 3 bits in error, if we
unscamble

the bits (shown
below) we can see now there is now just one bit in error in each codeword, and
so our data is correctable.

k1 k2 k3 k4 c1 c2 c3
k1 k2 k3 k4 c1 c2 c3

k1 k2 k3 k4 c1 c2 c3


x
x

x





15

More Sophisticated Codes


Sophisticated interleaving strategies are used in most advanced digital
recording systems.


CDs use product codes but with Reed
-
Solomon codes (not Hamming.)
They also use interleaving. DVDs and Blu
-
ray discs also use Reed
Solomon block codes.


Reed
-
Solomon (RS) codes work on groups (e.g., bytes) of inputs. For
bytes n<2
8

(codewords are a maximum of 255 bytes). There is only a
very small probability of ‘crypto
-
errors’, i.e., correcting good bytes by
mistake.


RS block codes can correct (n
-
k)/2 bytes and detect (n
-
k) bytes. For
example, RS(122,106) can correct (122
-
106)/2 = 8 bytes in error.


Other systems use layers of error correction. If a lower (simpler) layer
detects errors, the next (more powerful) layer is inspected. If errors are
still detected the final layer is interrogated. This method increases the
speed of decoding by only computing check bytes when errors are
suspected. DAT tape drives uses 3 layers of error control.


16

IP Checksum


The IP checksum is an IP header field. It is calculated using the
contents of the header.


It was designed for ease of implementation in software (rather
than its error
-
detection ability) because it has needed to be
recalculated (IPv4) at every router.


Consider L 16
-
bit words making up the information bits (IP
header).



Checksum,

b
L
, is given by :
b
L
=
-
x


So that adding the 16
-
bit words and the checksum (as below)
gives 0.



(Assessment does not require worked examples.

For interest only, this is a tutorial example of how the checksum is calculated with 1’s complement arithmetic is
http://www.netfor2.com/checksum.html

)


17

Polynomial/Cyclic Redundancy Check (CRC) Codes

k information bits

(
i
k
-
1
, i
k
-
2
, .... i
1
,i
0
) create an information polynomial
i
(x)
, of degree

k
-
1
.


i
(x)=i
k
-
1
x
k
-
1

+ i
k
-
2
x
k
-
2

+ ... + i
1
x + i
0


i
(x) and a generator polynomial, g(x), are used to calculate a
codeword polynomial, b(x).


Checksum calculation :

Divide
x
n
-
k
i
(x)

by
g(x)

to obtain the remainder
r(x)
.

x
n
-
k
i
(x)=g(x).q(x) + r(x)

(
q(x)
= quotient and
r(x)
=remainder)





b(x) = x
n
-
k
i(x) + r(x)

n

bits

k

bits

n
-
k

bits

18

Binary Polynomial Division

Division with Decimal Numbers

32

35 ) 1222

3

105

17

2

4

140

divisor

quotient

remainder

dividend

1222 = 34 x 35 + 32

dividend = quotient x divisor +remainder

Polynomial Division

x
3
+
x

+ 1 )
x
6
+
x
5

x
6
+
x
4
+
x
3

x
5
+
x
4
+
x
3

x
5
+
x
3
+
x
2

x
4
+
x
2

x
4
+
x
2
+
x

x

=
q(x)

quotient

=
r(x)

remainder

divisor

dividend

+
x

+
x
2

x
3

Note: Degree of r(x) is less than
degree of divisor

Transmitted codeword:

b(x) = x
6

+ x
5
+ x

b

= (1,1,0,0,0,1,0)

1011 ) 1100000


1110

1011

1110

1011

1010

1011

010

x
3
+ x

+
1

) x
6
+ x
5

x
3
+ x
2
+ x

x
6
+ x
4
+ x
3

x
5
+ x
4
+ x
3

x
5
+ x
3
+ x
2

x
4
+ x
2

x
4
+ x
2
+ x

x

Polynomial Example:
k
= 4,
n

k
= 3

Generator polynomial:


g(x)= x
3
+ x +
1

Information: (1,1,0,0)

i(x) = x
3

+ x
2

Encoding:



x
3
i(x) = x
6

+ x
5


Examples of Standard Generator Polynomials


CRC
-
8:




CRC
-
16:




CCITT
-
16:



CCITT
-
32:


CRC = cyclic redundancy check

ISO HDLC, XMODEM, V.41, Bluetooth

IEEE 802, DoD, V.42, MPEG
-
2

IBM Bisync

ATM


= x
8
+ x
2
+ x +

1

= x
16
+ x
15
+ x
2

+

1

= (
x

+ 1)(
x
15
+ x +

1)

= x
16
+ x
12
+ x
5

+

1

= x
32
+ x
26
+ x
23

+

x
22
+


x
16
+ x
12

+ x
11
+ x
10
+ x
8

+



x
7
+ x
5
+ x
4

+ x
2
+ x

+
1

Thank You





Recommended private study exercise

: read the error control
coding section from Chapter 3 of the recommended text.

Use the content of the slides to guide your revision. Methods
not referred to in the slides will not be assessed.