The Data Link Layer

Chapter 3
• Data Link Layer Design Issues
• Error Detection and Correction
• Elementary Data Link Protocols
• Sliding Window Protocols
• Example Data Link Protocols
 The Data Link Layer
Application
Transport
Network
Link
Physical
• This study deals with algorithms for achieving reliable,
efficient communication of whole units of information called
frames (rather than individual bits, as in the physical layer)
between two adjacent machines
• Responsible for delivering frames of information over a single
link
• Handles transmission errors and regulates the flow of data
• The data link layer uses the services of the physical layer to send
and receive bits over communication channels.
• It has a number of functions, including:

1. Providing a well-defined service interface to the network layer.

2. Dealing with transmission errors.

3. Regulating the flow of data so that slow receivers are not

swamped by fast senders.
• To accomplish these goals, the data link layer takes the packets it
gets from the network layer and encapsulates them into frames
for transmission.
• Each frame contains a frame header, a payload field for holding
the packet, and a frame trailer.
Data Link Layer Design Issues

• Frames »
• Possible services »
• Framing methods »
• Error control »
• Flow control »
 Frames
Link layer accepts packets from the network layer, and
encapsulates them into frames that it sends using the physical
layer; reception is the opposite process

Network

Link
Virtual data path

Physical Actual data path

Figure 3-1. Relationship between packets and frames.

 Services Provided to the Network Layer
•The function of the data link layer is to provide services to the
network layer.
•The principal service is transferring data from the network layer
on the source machine to the network layer on the destination
machine.
•On the source machine is an entity, call it a process, in the
network layer that hands some bits to the data link layer for
transmission to the destination.
•The job of the data link layer is to transmit the bits to the
destination machine so they can be handed over to the network
layer there.
• The job of the data link layer is to transmit the bits to the destination
machine so they can be handed over to the network layer there, as
shown in Fig. 3-2(a).

• The actual transmission follows the path of Fig. 3-2(b), but it is easier
to think in terms of two data link layer processes communicating
using a data link protocol.

• For this reason, we will implicitly use the model of Fig. 3-2(a)
throughout this chapter
 Possible Services
• The data link layer can be designed to offer various services.

• The actual services that are offered vary from protocol to

protocol.
• Three services of data link are:

1. Unacknowledged connectionless service

• Frame is sent with no connection / error recovery
Ex: Ethernet, No logical connection, attempt is made to detect the loss or
recover

2. Acknowledged connectionless service

• Frame is sent with retransmissions if needed

Example is 802.11 (WiFi)

3. Acknowledged connection-oriented service
• establish a connection before any data are transferred.
• Connection is set up; frames are received in the right order.
 Unacknowledged connectionless service
•Unacknowledged connectionless service consists of having the
source machine send independent frames to the destination machine
without having the destination machine acknowledge them.

•Ethernet is a good example of a data link layer that provides this class
of service.

•No logical connection is established beforehand or released

afterward.

•If a frame is lost due to noise on the line, no attempt is made to detect
the loss or recover from it in the data link layer.

•This class of service is appropriate when the error rate is very low, so
recovery is left to higher layers.
 Acknowledged connectionless service.
•Reliability is acknowledged connectionless service.

•When this service is offered, there are still no logical connections used,
but each frame sent is individually acknowledged.

•In this way, the sender knows whether a frame has arrived correctly or
been lost.

•This service is useful over unreliable channels, such as wireless

systems.

•802.11 (WiFi) is a good example of this class of service.

•Acknowledgements in the data link layer is just an optimization,
never a requirement.

•The network layer can always send a packet and wait for it to be
acknowledged by its peer on the remote machine.

•If the acknowledgement is not forthcoming before the timer expires,

the sender can just send the entire message again.

•The trouble with this strategy is that it can be inefficient.

•Links usually have a strict maximum frame length imposed by the

hardware, and known propagation delays
•The network layer does not know these parameters. It might send
a large packet that is broken up into, say, 10 frames, of which 2
are lost on average.

•It would then take a very long time for the packet to get through.

•Instead, if individual frames are acknowledged and retransmitted,

then errors can be corrected more directly and more quickly.

•On reliable channels, such as fiber, the overhead of a

heavyweight data link protocol may be unnecessary, but on
(inherently unreliable) wireless channels it is well worth the cost.
 Acknowledged connection-oriented service

•The most sophisticated service the data link layer can provide to
the network layer is connection-oriented service.
•With this service, the source and destination machines establish a
connection before any data are transferred.
•Each frame sent over the connection is numbered, and the data
link layer guarantees that each frame sent is indeed received.
•It guarantees that each frame is received exactly once and that all
frames are received in the right order.
•Connection-oriented service thus provides the network layer
processes with the equivalent of a reliable bit stream
When connection-oriented service is used, transfers go through
three distinct phases.

1. In the first phase, the connection is established by having both

sides initialize variables and counters needed to keep track of
which frames have been received and which ones have not.

2. In the second phase, one or more frames are actually

transmitted.

3. In the third and final phase, the connection is released, freeing

up the variables, buffers, and other resources used to maintain
the connection.
 Framing
•To provide service to the network layer, the data link layer must use the
service provided to it by the physical layer.

•What the physical layer does is accept a raw bit stream and attempt to
deliver it to the destination.

•If the channel is noisy, as it is for most wireless and some wired links,
the physical layer will add some redundancy to its signals to reduce the
bit error rate to a tolerable level.

•The bit stream received by the data link layer is not guaranteed to be
error free.

•Some bits may have different values and the number of bits received
may be less than, equal to, or more than the number of bits transmitted.

•It is up to the data link layer to detect and, if necessary, correct errors.
•The usual approach is for the data link layer to break up the bit stream
into discrete frames, compute a short token called a checksum for each
frame, and include the checksum in the frame when it is transmitted.

•When a frame arrives at the destination, the checksum is

recomputed.

•If the newly computed checksum is different from the one contained in
the frame, the data link layer knows that an error has occurred and takes
steps to deal with it (e.g., discarding the bad frame and possibly also
sending back an error report).

•A good design must make it easy for a receiver to find the start of new
frames while using little of the channel bandwidth.
 Framing Methods

• Byte count »
• Flag bytes with byte stuffing »
• Flag bits with bit stuffing »
• Physical layer coding violations
− Use non-data symbol to indicate frame
 Framing – Byte count
• The first framing method uses a field in the header to specify the
number of bytes in the frame.

• When the data link layer at the destination sees the byte count, it knows
how many bytes follow and hence where the end of the frame is.

• Frame begins with a count of the number of bytes in it

• Simple, but difficult to resynchronize after an error

Expected
case

Error
case

• It will then be unable to locate the correct start of the next frame.
•The trouble with this algorithm is that the count can be garbled
by a transmission error.

•For example, if the byte count of 5 in the second frame,

becomes a 7 due to a single bit flip, the destination will get out of
synchronization.

•It will then be unable to locate the correct start of the next frame.
 Framing – Byte stuffing

• The second framing method gets around the problem of

resynchronization after an error by having each frame start and end
with special bytes.

• Often the same byte, called a flag byte, is used as both the starting
and ending delimiter.

• Two consecutive flag bytes indicate the end of one frame and the start
of the next.

• Thus, if the receiver ever loses synchronization, it can just search for
two flag bytes to find the end of the current frame and the start of the
next frame.
•However, there is a still a problem we have to solve. It may
happen that the flag byte occurs in the data, especially
when binary data such as photographs or songs are being
transmitted.
•This situation would interfere with the framing.
•One way to solve this problem is to have the sender’s data
link layer insert a special escape byte (ESC) just before
each ‘‘accidental’’ flag byte in the data.
•A framing flag byte can be distinguished from one in the
data by the absence or presence of an escape byte before
it.
The data link layer on the receiving end removes the
escape bytes before giving the data to the network layer.
This technique is called byte stuffing.
 Framing – Byte stuffing
The byte-stuffing scheme depicted is a slight simplification of
the one used in PPP (Point-to-Point Protocol), which is
used to carry packets over communications links.

Frame
format

Need to escape
extra ESCAPE
bytes too!
Stuffing
examples
 Framing – Bit stuffing
The third method of delimiting the bit stream gets around a
disadvantage of byte stuffing, which is that it is tied to the use
of 8-bit bytes.
Framing can be also be done at the bit level, so frames can
contain an arbitrary number of bits made up of units of any
size.
It was developed for the once very popular HDLC (Highlevel
Data Link Control) protocol.
Each frame begins and ends with a special bit pattern,
01111110 or 0x7E in hexadecimal.
This pattern is a flag byte.
Whenever the sender’s data link layer encounters five consecutive 1s in
the data, it automatically stuffs a 0 bit into the outgoing bit stream.

This bit stuffing is analogous to byte stuffing, in which an escape byte

is stuffed into the outgoing character stream before a flag byte in the data.

When the receiver sees five consecutive incoming 1 bits, followed by a 0

bit, it automatically destuffs (i.e., deletes) the 0 bit. Just as byte stuffing is
completely transparent to the network layer in both computers, so is bit
stuffing.

If the user data contain the flag pattern, 01111110, this flag is transmitted
as 011111010 but stored in the receiver’s memory as 01111110.
•With bit stuffing, the boundary between two frames can
be unambiguously recognized by the flag pattern.
•Thus, if the receiver loses track of where it is, all it has
to do is scan the input for flag sequences, since they
can only occur at frame boundaries and never within the
data.
 Framing – Bit stuffing

Stuffing done at the bit level:

• Frame flag has six consecutive 1s (not shown)
• On transmit, after five 1s in the data, a 0 is added
• On receive, a 0 after five 1s is deleted

Data bits

Transmitted bits
with stuffing
 Coding Violations
•The last method of framing is to use a shortcut from the physical
layer.

•The encoding of bits as signals often includes redundancy to help the

receiver.

•This redundancy means that some signals will not occur in regular
data.

•For example, in the 4B/5B line code 4 data bits are mapped to 5
signal bits to ensure sufficient bit transitions.

•We can use some reserved signals to indicate the start and end of
frames. In effect, we are using ‘‘coding violations’’ to delimit frames.

• The beauty of this scheme is that, because they are reserved signals,
it is easy to find the start and end of frames and there is no need to
stuff the data.
 Error Control

Error control repairs frames that are received in error

• Requires errors to be detected at the receiver
• Typically retransmit the unacknowledged frames
• Timer protects against lost acknowledgements

Detecting errors and retransmissions are next topics.

•How to make sure all frames are eventually delivered to the network
layer at the destination and in the proper order.

•For unacknowledged connectionless service it might be fine if the

sender just kept outputting frames without regard to whether they were
arriving properly.

•But for reliable, connection-oriented service it would not be fine at all.

•The usual way to ensure reliable delivery is to provide the sender with
some feedback about what is happening at the other end of the line.
Typically, the protocol calls for the receiver to send back special control
frames bearing positive or negative acknowledgements about the
incoming frames.

•If the sender receives a positive acknowledgement about a frame, it

knows the frame has arrived safely.

•On the other hand, a negative acknowledgement means that something

has gone wrong and the frame must be transmitted again.
•When the sender transmits a frame, it generally also starts a timer. The
timer is set to expire after an interval long enough for the frame to reach
the destination, be processed there, and have the acknowledgement
propagate back to the sender.

•Normally, the frame will be correctly received and the acknowledgement

will get back before the timer runs out, in which case the timer will be
canceled.

•However, if either the frame or the acknowledgement is lost, the timer will
go off, alerting the sender to a potential problem.

•The obvious solution is to just transmit the frame again. However, when
frames may be transmitted multiple times there is a danger that the
receiver will accept the same frame two or more times and pass it to the
network layer more than once.

•To prevent this from happening, it is generally necessary to assign

sequence numbers to outgoing frames, so that the receiver can
distinguish retransmissions from originals.
 Flow Control

Prevents a fast sender from out-pacing a slow receiver

• Receiver gives feedback on the data it can accept
• Rare in the Link layer as NICs run at “wire speed”
− Receiver can take data as fast as it can be sent

Flow control is a topic in the Link and Transport layers.

•Another important design issue that occurs in the data link layer (and
higher layers as well) is what to do with a sender that systematically
wants to transmit frames faster than the receiver can accept them.

• This situation can occur when the sender is running on a fast, powerful
computer and the receiver is running on a slow, low-end machine.

•Two approaches are commonly used:

•In the first one, feedback-based flow control, the receiver sends
back information to the sender giving it permission to send more data, or
at least telling the sender how the receiver is doing.

In the second one, rate-based flow control, the protocol has a built-
in mechanism that limits the rate at which senders may transmit data,
without using feedback from the receiver.
 Error Detection and Correction

Error codes add structured redundancy to data so errors

can be either detected, or corrected.
Error correction codes:
• Hamming codes »
• Binary convolutional codes »
• Reed-Solomon and Low-Density Parity Check codes
− Mathematically complex, widely used in real systems

Error detection codes:

• Parity »
• Checksums »
• Cyclic redundancy codes »
•Network designers have developed two basic strategies for
dealing with errors.
•Both add redundant information to the data that is sent.
•One strategy is to include enough redundant information to
enable the receiver to deduce what the transmitted data must
have been.
•The other is to include only enough redundancy to allow the
receiver to deduce that an error has occurred (but not which
error) and have it request a retransmission.
•The former strategy uses error-correcting codes and the
latter uses error-detecting codes. The use of error-
correcting codes is often referred to as FEC (Forward Error
Correction).
•On channels that are highly reliable, such as fiber, it is
cheaper to use an error-detecting code and just retransmit
the occasional block found to be faulty.

•However, on channels such as wireless links that make

many errors, it is better to add redundancy to each block so
that the receiver is able to figure out what the originally
transmitted block was.

•FEC is used on noisy channels because retransmissions

are just as likely to be in error as the first transmission.
Both models matter in practice, and they have different
trade-offs. Having the errors come in bursts has both
advantages and disadvantages over isolated single bit
errors.
On the advantage side, computer data are always sent in
blocks of bits.
Suppose that the block size was 1000 bits and the error rate
was 0.001 per bit. If errors were independent, most blocks
would contain an error.
If the errors came in bursts of 100, however, only one block
in 100 would be affected, on average.
The disadvantage of burst errors is that when they do occur
they are much harder to correct than isolated errors.
 Error-Correcting Codes

The four different error-correcting codes:

1. Hamming codes.
2. Binary convolutional codes.
3. Reed-Solomon codes.
4. Low-Density Parity Check codes.
•All of these codes add redundancy to the information that is sent.

•A frame consists of m data (i.e., message) bits and r redundant (i.e.

check) bits.

•In a block code, the r check bits are computed solely as a function
of the m data bits with which they are associated, as though the m bits
were looked up in a large table to find their corresponding r check bits.

•In a systematic code, the m data bits are sent directly, along with the
check bits, rather than being encoded themselves before they are sent.
In a linear code, the r check bits are computed as a linear function of
the m data bits. Exclusive OR (XOR) or modulo 2 addition is a popular
choice.

•This means that encoding can be done with operations such as matrix
multiplications or simple logic circuits.
•Let the total length of a block be n (i.e., n = m + r). We will
describe this as an (n,m) code.
•An n-bit unit containing data and check bits is referred to as
an n bit codeword.
•The code rate, or simply rate, is the fraction of the
codeword that carries information that is not redundant, or
m/n.
•The rates used in practice vary widely.
•They might be 1/2 for a noisy channel, in which case half of
the received information is redundant, or close to 1 for a high-
quality channel, with only a small number of check bits added
to a large message.
It is necessary to first look closely at what an error really is.
Given any two codewords that may be transmitted or
received—say, 10001001 and 10110001—it is possible to
determine how many corresponding bits differ. In this case, 3
bits differ.
To determine how many bits differ, just XOR the two
codewords and count the number of 1 bits in the result.
For example:
10001001
10110001
00111000
•The number of bit positions in which two codewords differ is called the
Hamming distance (Hamming, 1950).

•Its significance is that if two codewords are a Hamming distance d

apart, it will require d single-bit errors to convert one into the other.

•As a simple example of an error-correcting code, consider a code with

only four valid codewords:

•0000000000, 0000011111, 1111100000, and 1111111111

•This code has a distance of 5, which means that it can correct double
errors or detect quadruple errors.

•If the codeword 0000000111 arrives and we expect only single- or

double-bit errors, the receiver will know that the original must have been
0000011111. If, however, a triple error changes 0000000000 into
0000000111, the error will not be corrected properly
Error Bounds – Hamming distance

Code turns data of n bits into codewords of n+k bits

Hamming distance is the minimum bit flips to turn one
valid codeword into any other valid one.
• Example with 4 codewords of 10 bits (n=2, k=8):
− 0000000000, 0000011111, 1111100000, and 1111111111
− Hamming distance is 5

Bounds for a code with distance:

• 2d+1 – can correct d errors (e.g., 2 errors above)
• d+1 – can detect d errors (e.g., 4 errors above)
 Error Correction – Hamming code

Hamming code gives a simple way to add check bits

and correct up to a single bit error:
• Check bits are parity over subsets of the codeword
• Recomputing the parity sums (syndrome) gives the
position of the error to flip, or 0 if there is no error

(11, 7) Hamming code adds 4 check bits and can correct 1 error
 Error Correction – Convolutional codes

Operates on a stream of bits, keeping internal state

• Output stream is a function of all preceding input bits
• Bits are decoded with the Viterbi algorithm

…111 … 0 1 1
1 0 1

Popular NASA binary convolutional code (rate = ½) used in 802.11

 Error Detection – Parity (1)

Parity bit is added as the modulo 2 sum of data bits

• Equivalent to XOR; this is even parity
• Ex: 1110000  11100001
• Detection checks if the sum is wrong (an error)

Simple way to detect an odd number of errors

• Ex: 1 error, 11100101; detected, sum is wrong
• Ex: 3 errors, 11011001; detected sum is wrong
• Ex: 2 errors, 11101101; not detected, sum is right!
• Error can also be in the parity bit itself
• Random errors are detected with probability ½
 Error Detection – Parity (2)

Interleaving of N parity bits detects burst errors up to N

• Each parity sum is made over non-adjacent bits
• An even burst of up to N errors will not cause it to fail
 Error Detection – Checksums

Checksum treats data as N-bit words and adds N check

bits that are the modulo 2N sum of the words
• Ex: Internet 16-bit 1s complement checksum

Properties:
• Improved error detection over parity bits
• Detects bursts up to N errors
• Detects random errors with probability 1-2N
• Vulnerable to systematic errors, e.g., added zeros
 Error Detection – CRCs (1)
Adds bits so that transmitted frame viewed as a polynomial
is evenly divisible by a generator polynomial

Start by adding
0s to frame
and try dividing

Offset by any reminder

to make it evenly
divisible
 Error Detection – CRCs (2)

Based on standard polynomials:

• Ex: Ethernet 32-bit CRC is defined by:

• Computed with simple shift/XOR circuits

Stronger detection than checksums:

• E.g., can detect all double bit errors
• Not vulnerable to systematic errors
Elementary Data Link Protocols

• Link layer environment »

• Utopian Simplex Protocol »
• Stop-and-Wait Protocol for Error-free channel »
• Stop-and-Wait Protocol for Noisy channel »
 Link layer environment (1)

Commonly implemented as NICs and OS drivers;

network layer (IP) is often OS software
 Link layer environment (2)
Link layer protocol implementations use library functions
• See code (protocol.h) for more details

Group Library Function Description

from_network_layer(&packet) Take a packet from network layer to send
Network to_network_layer(&packet) Deliver a received packet to network layer
layer enable_network_layer() Let network cause “ready” events
disable_network_layer() Prevent network “ready” events
Physical from_physical_layer(&frame) Get an incoming frame from physical layer
layer to_physical_layer(&frame) Pass an outgoing frame to physical layer
wait_for_event(&event) Wait for a packet / frame / timer event
start_timer(seq_nr) Start a countdown timer running
Events &
stop_timer(seq_nr) Stop a countdown timer from running
timers
start_ack_timer() Start the ACK countdown timer
stop_ack_timer() Stop the ACK countdown timer
 Utopian Simplex Protocol

An optimistic protocol (p1) to get us started

• Assumes no errors, and receiver as fast as sender
• Considers one-way data transfer

Sender loops blasting frames Receiver loops eating frames

• That’s it, no error or flow control …

Stop-and-Wait – Error-free channel
Protocol (p2) ensures sender can’t outpace receiver:
• Receiver returns a dummy frame (ack) when ready
• Only one frame out at a time – called stop-and-wait
• We added flow control!

Sender waits to for ack after Receiver sends ack after passing
passing frame to physical layer frame to network layer
Stop-and-Wait – Noisy channel (1)

ARQ (Automatic Repeat reQuest) adds error control

• Receiver acks frames that are correctly delivered
• Sender sets timer and resends frame if no ack)

For correctness, frames and acks must be numbered

• Else receiver can’t tell retransmission (due to lost
ack or early timer) from new frame
• For stop-and-wait, 2 numbers (1 bit) are sufficient
 Stop-and-Wait – Noisy channel (2)
{

Sender loop (p3):

Send frame (or retransmission)

Set timer for retransmission
Wait for ack or timeout

If a good ack then set up for the

next frame to send (else the old
frame will be retransmitted)
 Stop-and-Wait – Noisy channel (3)

Receiver loop (p3):

Wait for a frame

If it’s new then take

it and advance
expected frame

Ack current frame

 Sliding Window Protocols

• Sliding Window concept »

• One-bit Sliding Window »
• Go-Back-N »
• Selective Repeat »
 Sliding Window concept (1)

Sender maintains window of frames it can send

• Needs to buffer them for possible retransmission
• Window advances with next acknowledgements

Receiver maintains window of frames it can receive

• Needs to keep buffer space for arrivals
• Window advances with in-order arrivals
 Sliding Window concept (2)

A sliding window advancing at the sender and receiver

• Ex: window size is 1, with a 3-bit sequence number.

Sender

Receiver

At the start First frame First frame Sender gets

is sent is received first ack
 Sliding Window concept (3)

Larger windows enable pipelining for efficient link use

• Stop-and-wait (w=1) is inefficient for long links
• Best window (w) depends on bandwidth-delay (BD)
• Want w ≥ 2BD+1 to ensure high link utilization

Pipelining leads to different choices for errors/buffering

• We will consider Go-Back-N and Selective Repeat
 One-Bit Sliding Window (1)
Transfers data in both directions with stop-and-wait
• Piggybacks acks on reverse data frames for efficiency
• Handles transmission errors, flow control, early timers
{

Each node is sender

and receiver (p4):

Prepare first frame

Launch it, and set timer

...
 One-Bit Sliding Window (2)
...
Wait for frame or timeout

If a frame with new data

then deliver it

If an ack for last send then

prepare for next data frame

(Otherwise it was a timeout)

Send next data frame or

retransmit old one; ack
the last data we received
 One-Bit Sliding Window (3)
Two scenarios show subtle interactions exist in p4:
− Simultaneous start [right] causes correct but slow operation
compared to normal [left] due to duplicate transmissions.

Time

Notation is (seq, ack, frame number). Asterisk indicates frame accepted by network layer .

Normal case Correct, but poor performance

 Go-Back-N (1)

Receiver only accepts/acks frames that arrive in order:

• Discards frames that follow a missing/errored frame
• Sender times out and resends all outstanding frames
 Go-Back-N (2)

Tradeoff made for Go-Back-N:

• Simple strategy for receiver; needs only 1 frame
• Wastes link bandwidth for errors with large
windows; entire window is retransmitted

Implemented as p5 (see code in book)

 Selective Repeat (1)

Receiver accepts frames anywhere in receive window

• Cumulative ack indicates highest in-order frame
• NAK (negative ack) causes sender retransmission of
a missing frame before a timeout resends window
 Selective Repeat (2)

Tradeoff made for Selective Repeat:

• More complex than Go-Back-N due to buffering
at receiver and multiple timers at sender
• More efficient use of link bandwidth as only lost
frames are resent (with low error rates)

Implemented as p6 (see code in book)

 Selective Repeat (3)

For correctness, we require:

• Sequence numbers (s) at least twice the window (w)

Error case (s=8, w=7) – too Correct (s=8, w=4) – enough

few sequence numbers sequence numbers

Originals Retransmits Originals Retransmits

New receive window overlaps New and old receive window

old – retransmits ambiguous don’t overlap – no ambiguity
 Example Data Link Protocols

• Packet over SONET »

• PPP (Point-to-Point Protocol) »
• ADSL (Asymmetric Digital Subscriber Loop) »
 End

Chapter 3