Data Communication Networks
Lecture 2
Saad Mneimneh
Computer Science
Hunter College of CUNY
New York
DLC . . . . . . . . . . . . . . . . . . . . . .
Framing . . . . . . . . . . . . . . . . . . . .
Character based framing . . . . . . . . .
Character based framing (cont.) . . . .
Length field . . . . . . . . . . . . . . . . .
Maximum frame size . . . . . . . . . . .
Maximum frame size (cont.) . . . . . .
Fixed length packets/frames . . . . . .
Bit oriented framing . . . . . . . . . . . .
Bit stuffing . . . . . . . . . . . . . . . . . .
Overhead of bit stuffing . . . . . . . . .
Overhead of bit stuffing (cont.) . . . .
Can we do better? . . . . . . . . . . . . .
Error detection . . . . . . . . . . . . . . .
How to detect errors? . . . . . . . . . . .
Single parity check . . . . . . . . . . . . .
Horizontal and vertical parity checks .
Horizontal and vertical parity checks .
Horizontal and vertical parity checks .
Arbitrary parity check codes . . . . . .
Effectiveness of a code . . . . . . . . . .
Effectiveness of a code (cont.) . . . . .
Cyclic Redundancy Check . . . . . . . .
Obtaining c(x) . . . . . . . . . . . . . . .
Another example . . . . . . . . . . . . . .
Using bits only . . . . . . . . . . . . . . .
Using bits only (cont.) . . . . . . . . . .
Using bits only (cont.) . . . . . . . . . .
Feedback shift register . . . . . . . . . .
How does c(x) help? . . . . . . . . . . .
Undetected errors . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
DLC
We are not going to study the physical layer and how communication signals are sent and received
We will assume that we are capable of sending bits over a link
DLC is responsible for reliable transmission of packets over a link
every packet is delivered once,
only once,
without errors,
and in order
To achieve this goal, we have:
Framing: determine start and end of packets
Error detection: determine when errors exist
Error correction: retransmit packets containing errors
Framing
Recall that DLC adds its own header and trailer to the packet frame
header
packet
trailer
frame
The problem is to decide where successive frames start and end
in some cases, there is a period of idle fills between successive frames (e.g. synchronous bit
pipe)
it is also necessary to separate idle fills from frames
even when idle fill are replaces by dead periods (intermittent bit pipe), problem is not
simplified, e.g. often no dead periods
. . . 01011010110010110101101110101110 . . .
Where is the data?
Character based framing
Character based codes, such as ASCII (7 bits and 1 parity bit), provide binary representation for keyboard
characters and terminal control characters
Such codes can also provide representation for various communication characters
SYN: a string of SYN characters provide idle fill between frames when a sending DLC has no data to
send (but a synchronous modem requires bits)
STX: start of text
ETX: end of text
frame
SYN
SYN
STX
header
packet
ETX
CRC
SYN
SYN
trailer added by DLC
for error detection
(later)
Frame must contain integer number of characters
Frame is character code dependent how do we send binary data
e.g. packet is an arbitrary binary string and may possibly contain the ETX character for instance, which
could be wrongly interpreted as end of frame
Character based framing (cont.)
A special control character DLE (Data Link Escape) is inserted before any intentional use of
communication control characters
e.g. DLE is not inserted before the possible appearance these characters as part of the binary
data
But what if DLE appears itself in the data?
Insert a DLE before each appearance of DLE in data
e.g. DLE ETX (but not DLE DLE ETX): end of frame
e.g. DLE DLE ETX (but not DLE DLE DLE ETX): DLE ETX in data
frame
SYN
SYN
DLE
STX
header
packet
Too much overhead: at least 6 characters/packet
Primary framing method from 1960-1975
DLE
ETX
CRC
SYN
SYN
Length field
The basic problem is to inform the receiving DLC where each idle fill ends and where each frame
ends
idle fill: in principle, easy to identify because it is represented by a fixed string
frame: harder to indicate where it ends because it consists of arbitrary and unknown bit string
Include a length field of certain number of bits in header (e.g. DECNET)
length
Idle fill
|||||
packet
CRC
Idle fill
header
packet
CRC
header
Once synchronized, DLC can always tell where next frame starts
Length field restricts packet size
length field must be blog 2 M axF rameSizec + 1 bits (thats the overhead)
Difficult to recover from error in length field
e.g. resynchronization needed after error in length field
Maximum frame size
How should transport layer choose maximum packet size?
not a big deal since IP fragments packets further if necessary
usually about 1500 bytes (from Ethernet)
but theoretically speaking?
Let Kmax be the maximum packet size. Assume V overhead bits. Let M be the message length.
Then we have
M
M +d
eV
Kmax
bits to send
Kmax
Kmax
Therefore,
Kmax % small overhead per message
Kmax & faster delivery of message (why?)
Kmax
Rest V
Maximum frame size (cont.)
What is the time needed for the message to traverse j links?
receiver
1
2
sender
Assume capacity of link is c bps (bandwidth)
T =
M
(Kmax + V )(j 1) M + d Kmax eV
+
+P +Q
c
c
E[T ] (Kmax + V )(j 1) + E[M ] +
Minimizing (take first derivative and set it to zero)
Kmax =
Fixed length packets/frames
Length field is implicit (not needed)
e.g. ATM, all packets are 53 bytes
Requires synchronization upon initialization
Message length not multiple of packet size
last packet contains idle fill (efficiency?)
E[M ]V
j1
E[M ]
V
Kmax
Bit oriented framing
In character based framing, DLE ETX indicates the end of frame
avoided within frame by doubling each DLE character
In bit oriented framing, a special binary flag indicates the end of frame
avoided within frame using a technique called bit stuffing
The difference is that a flag can be of any length (later we see how to set length to minimize overhead)
Standard protocols use 01111110, we denote it by 01 6 0
The same flag can be used to indicate start of frame
01111110 . . . . . . . . . . . . . . . . . . 01111110
Standard DLCs have also an abort capability in which a frame can be aborted by sending 7 or more
consecutive 1s (15 consecutive 1s link is idle)
Therefore, 0111111, i.e. 016 is the actual bit string that must be avoided in data
Bit stuffing, 1970 by IBM
Bit stuffing
Sender DLC
insert (stuff) a 0 after each appearance of five consecutive 1s
append the flag 016 0 (without stuffing) at the end of frame
Receiver DLC
delete the first 0 after each string of five consecutive 1s
if six consecutive 1s are seen end of frame
stuffed bits
0
0
0
0
1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0
Which ones of these stuffed bits can be avoided (provided receivers rule for deleting stuffed bits is
changed accordingly)?
Overhead
of overhead
bit stuffing
What is the
of bit stuffing (assume flag = 01j 0)?
if j % less stuffing but longer flag
if j & more stuffing but shorter flag
For the sake of analysis, assume a random string of bits with p(0) = p(1) = 1/2
insertion after ith bit occurs with probability (1/2)j
01
. . 1}
| .{z
j1
also insertion after ith bit occurs with probability (1/2)2j1
. . 1}
01
. . 1} |1 .{z
| .{z
j1
j1
since (1/2)2j1 << (1/2)j , we can ignore such event and events of insertion dur to yet longer strings
of 1s
The probability of stuffing after the ith bit is approximately 2j , which is also E[stuf f ed @ i]
By linearity of expectation, E[stuf f ed|K] K2j (be careful at boundary), where K is the length of the
frame
Overhead
of bit
stuffing (cont.)
From previous
slide
E[stuf f ed] = E[K]2j
E[overhead] = E[K]2j + j + 2
| {z } | {z }
stuf f ed
f lag
Minimizing with respect to j, we need smallest j such that
E[K]2j + j + 2 < E[K]2(j+1) + (j + 1) + 2
j+1
E[k]2(j+1) < 1
The smallest j that satisfies above is j = blog2 E[k]c
We can show that (homework?)
log2 E[K] + 2.914 E[overhead] log2 E[K] + 3
Can we do better?
Length field based framing and bit oriented framing are comparable in their overhead
log 2 K
where K is the length of the frame
Can we do better? Information theory tells us NO.
Essentially, we are encoding information about the length of the frame at the sending DLC and
transmitting it to the receiving DLC
At least we need a number of bits equal to the entropy
H=
KX
max
p(k) log 2
k=1
When distribution is uniform, i.e. p =
1
Kmax ,
1
p(k)
H = log2 Kmax .
Error detection
All framing techniques are sensitive to errors
error in DLE ETX
error in length field (re-sync needed)
error in flag
error in data itself
Flag approach is least sensitive to errors because a flag will eventually appear
flag ruined (frame disappears)
flag created by error (extra frame appears)
the only thing is that an erroneous packet/frame is created
but this can be removed by error detection techniques
Error detection is used by receiving DLC to determine if a frame contains errors
If frame contains errors, receiver requires the transmitter to resend the frame
How to detect errors?
The problem (simply stated)
Assume that DLC knows where frames begin and end (solved earlier)
Determine which frames contain errors
Error cannot be detected by analyzing the packet itself (why?)
Therefore, extra bits must be used
Parity check
single parity
multiple parity (e.g. horizontal and vertical)
Cyclic Redundancy Check CRC
Single parity check
Add one parity bit
Parity bit is 1 if frame contains ODD number of 1s, and 0 otherwise
e.g. 1001010 1
e.g. 0111010 0
Therefore, a frame always contains an even number of 1s
Receiver counts number of 1s
ODD number of 1s: an error must have occurred
EVEN number of 1s: interpret as no error (why?)
even number of errors cannot be detected!
P
p(undetected error) = i even ki pi (1 p)i assuming independent errors (simplification),
where k is the length of the frame, p is the probability of error (binary symmetric channel)
Horizontal and vertical parity checks
Data is visualized as a rectangular array
1
0
1
1
0
0
1
1
0
0
0
1
1
0
1
1
1
0
0
1
0
0
0
1
0
1
1
0
1
0
0
0
1
1
1
Parity bit is computed for every row and every column
If an even number of errors is confined to a single row, each of them can be detected by the
corresponding column parity checks (and vice-versa)
Horizontal and vertical parity checks
Data is visualized as a rectangular array
1
0
1
1
0
1
0
1
1
0
0
0
0
1
1
0
1
1
1
1
0
0
1
1
0
0
0
1
0
1
1
1
0
1
0
1
0
0
1
1
1
1
1
0
0
0
1
0
horizontal checks
always consistent with both checks
(why?) (addition modulo 2)
vertical checks
Parity bit is computed for every row and every column
If an even number of errors is confined to a single row, each of them can be detected by the
corresponding column parity checks (and vice-versa)
Horizontal and vertical parity checks
Data is visualized as a rectangular array
1
0
1
1
0
1
0
1
1
0
0
0
0
1
1
0
1
1
1
1
0
0
1
1
0
0
0
1
0
1
1
1
0
1
0
1
0
0
1
1
1
1
1
0
0
0
1
0
horizontal checks
always consistent with both checks
(why?) (addition modulo 2)
vertical checks
Parity bit is computed for every row and every column
If an even number of errors is confined to a single row, each of them can be detected by the
corresponding column parity checks (and vice-versa)
Some errors are still undetected
e.g. any 4 errors forming a rectangle
Arbitrary parity check codes
Parity check code is simply addition modulo 2
s1 s2 . . . s k c1 c2 . . . cL
{z
} |
{z
}
|
Kbit frame
Lbit parity check
every ci is the sum of some bits in s1 . . . sK
ci =
K
X
ij sj
j=1
where
s1 is
0
0
0
0
1
1
1
1
an
s2 L
s3K
0
0
0
1
1
0
1
1
0
0
0
1
1
0
1
1
0-1
c1
0
1
0
1
1
0
1
0
matrix
c2 c3
0
0
1
0
1
1
0
1
1
1
0
1
0
0
1
0
c4
0
1
1
0
0
1
1
0
c1
c2
c3
c4
= s1 + s3
= s1 + s2 + s3
= s1 + s2
= s2 + s3
1
1
=
1
0
0
1
1
1
1
1
0
1
Effectiveness of a code
K
|
L
{z
codeword
The effectiveness of a code is usually measured by three parameters
minimum distance of the code d: the smallest number of errors that can convert one code word
into another
burst detecting capability
burst = number of bits from first error to last error (inclusive)
defined as: largest integer B such that a code can detect all bursts B
probability that a random string is accepted as error free
useful when framing is lost, e.g. check code is random with respect to received frame
We have 2K codewords (why?) and 2K+L random strings
therefore, the probability is 2L
Effectiveness of a code (cont.)
Minimum distance d
single parity:
horz. and vert. parity:
Burst detecting capability B
single parity:
horz. and vert. parity (assumes data sent by rows):
Cyclic Redundancy Check
For convenience, denote the data bits as
sK1 , sK2 , . . ., s0
Represent the string as a polynomial
s(x) = sK1 xK1 + sK2 xK2 + . . . + s1 x + s0
Similarly, we can represent the CRC (with L bits) as
c(x) = cL1 xL1 + cL2 xL2 + . . . + c1 x + c0
The whole frame can be represented as a polynomial
f (x) = s(x)xL + c(x) = sK1 xL+K1 + . . . + s0 xL + cL1 xL1 + . . . + c0
|{z}
|{z}
| {z }
| {z }
Why this polynomial representation? because we are going to obtain c as c(x) by dividing s(x)x L by some
polynomial g(x)
Obtaining c(x)
We know si (data) for i = 0 . . . K 1
How do we compute ci (CRC) for i = 0 . . . L 1?
let g(x) = xL + gL1 xL1 + . . . + g1 x + 1 be given (gL = g0 = 1)
then
"
#
s(x)xL
c(x) = Remainder
g(x)
- division modulo 2
result is a degree L 1 polynomial L bits
Example: s = 101 (K = 3) and g(x) = x3 + x2 + 1 (L = 3)
s(x) =?
s(x)xL =?
divide s(x)xL by g(x) and obtain remainder (ill do it on the board?)
Another example
s = 110101
g(x) = x3 + 1
s(x) = x5 + x4 + x2 + 1
s(x)xL = x8 + x7 + x5 + x3
x8 + x 7 + x 5 + x 3
x8 + x 5
x7 + x 3
x7 + x 4
x4 + x 3
x4 + x
x3 + x
x3 + 1
x+1
x3 + 1
x5 +x4 +x+1
c(x) = 0.x2 + 1.x + 1 (L = 3) c = 011
110101 011
Using bits only
s = 110101
g(x) = x3 + 1 (L = 3)
g=
x3
x2
x1
x0
L
s(x)xL
x8
x7
x6
x5
x4
x3
x2
}|
x1
x0
Using bits only (cont.)
1 1 0 1 0 1 0 0 0
1 0 0 1
1 0 0 1
1 1 0 0 1 1
1 0 0 0
1 0 0 1
0 0 1 1
0 0 0 0
0 1 1 0
0 0 0 0
1 1 0 0
1 0 0 1
1 0 1 0
1 0 0 1
0 1 1
Using bits only (cont.)
1 1 0 1 0 1 0 0 0
1 0 0 1
1 0 0 1
1 1 0 0 1 1
1 0 0 0
1 0 0 1
0 0 1 1
0 0 0 0
0 1 1 0
0 0 0 0
1 1 0 0
1 0 0 1
1 0 1 0
1 0 0 1
0 1 1
Multiply g by first bit
Add
Shift
Can be implemented using a feedback shift register
Feedback shift register
g0
g1
g2
gL-2
gL-1
s0 sK-L-1
sK-L
sK-L+1
sK-2
Register is initialized with first L bits of s
After K shifts, switch is moved and CRC is read
How does c(x) help?
s(x)xL = g(x)z(x) + c(x)
s(x)xL + c(x) = g(x)z(x) + c(x) + c(x) (modulo 2)
|
{z
0
s(x)xL + c(x) = g(x)z(x)
f (x) = g(x)z(x)
Polynomial representation of the frame is multiple of g(x)
Assume f (x) received as y(x)
Receiver DLC computers
y(x)
Remainder
g(x)
if remainder is not zero error in frame
if remainder is zero, declare the frame error free
sK-1
Undetected errors
Assume error is e(x), i.e. y(x) = f (x) + e(x)
f (x)
e(x)
Then, y(x)
g(x) = g(x) + g(x)
Therefore, we have undetected errors iff e(x) 6= 0 divisible by g(x)
Single errors are always detected
assume undetected, i.e. e(x) = xi = g(x)z(x) for some i
since g(x) = xL + . . . + 1, multiplying g(x) by any z(x) 6= 0 cannot produce x i (must produce at least
2 terms)
g(x) can be chosen such that
all odd number of errors are detected
all double errors are detected (if K + L < 2L )
therefore, minimum distance d = 4
burst detecting capability B = L
probability of random string accepted is 2L
e.g. (L=16) g(x) = x16 + x15 + x2 + 1 CRC-16
e.g. (L=16) g(x) = x16 + x12 + x5 + 1 CRC-CCITT
e.g. (L=32) g(x) = ... (see book page 64)
