Presentation is loading. Please wait.

Presentation is loading. Please wait.

Chapter 3 The Data Link Layer.

Similar presentations


Presentation on theme: "Chapter 3 The Data Link Layer."— Presentation transcript:

1 Chapter 3 The Data Link Layer

2 Data Link Layer Design Issues
Services Provided to the Network Layer Framing Error Control Flow Control

3 Functions of the Data Link Layer
Provide service interface to the network layer Dealing with transmission errors Regulating data flow Slow receivers not swamped by fast senders Services provided: Unacknowledged connectionless service (e.g. if error rate low, for voice transmission, or for LANs) Acknowledged connectionless service (e.g. for wireless systems: retransmissions are possible) Acknowledged connection-oriented service  frames guaranteed to be received in right order and exactly once  3 phases: initialization, transmission, release

4 Functions of the Data Link Layer (2)
Relationship between packets and frames.

5 Services Provided to Network Layer
(a) Virtual communication. (b) Actual communication.

6 Services Provided to Network Layer (2)
Placement of the data link protocol.

7 A character stream. (a) Without errors. (b) With one error.
Framing A character stream. (a) Without errors. (b) With one error.

8 Framing (2) (a) A frame delimited by flag bytes.
(b) Four examples of byte sequences before and after stuffing.

9 Framing (3) Bit stuffing (e.g. 01111110 is delimiter)
(a) The original data. (b) The data as they appear on the line. (c) The data as they are stored in receiver’s memory after destuffing.

10 Error Detection and Correction
Types of Errors Error-Correcting Codes Error-Detecting Codes

11 Types of Errors Single-Bit Error: Burst Error: (a) (b)

12  All error detection/correction methods are based on redundancy

13 Error Detection Four basic detection methods: VRC (Parity Bit Method):
Vertical Redundancy Check (VRC) Longitudinal Redundancy Check (LRC) Cyclic Redundancy Check (CRC) Checksum VRC (Parity Bit Method): Single-Bit errors are always detected. Burst errors detected, if number of errors is odd.

14 LRC Original data LRC Original data plus LRC LRC detects burst errors better than VRC:  Bursts less than number of columns are detected with a high probability Some error patterns remain undetected:  e.g. 2 bits in the same position but in different rows change their values

15 CRC r bits r+1 bits r bits

16 CRC CRC Algorithm: f = M.2r
Let M be the frame to be sent. M is interpreted as a binary number. Let G (divisor) be a binary number agreed on between sender and receiver. G should have r + 1 bits (G is the so-called generator polynomial of degree r). Append r zero bits to right-end of the frame M and get f: f = M.2r Divide the “bit string” f by G (using modulo 2 division): f = p.G + R (R has r or fewer bits and is the CRC) Get T = f + R (= f – R = p.G, which is divisible by G) T is now the checksummed frame to be transmitted.

17 Message transmitted: T = 100100001
CRC Example: G M Message transmitted: T =

18 Standard polynomials:
CRC Why polynomials? Standard polynomials: (IEEE 802)

19 CRC CRC Performance: Assume an error is described as a bit string E:
e.g. E = means 2 error in second and fourth bit (from the right) Receiver gets: T + E Since T is divisible by G, E/G will determine whether or not an error can be detected. Cases: Single-Bit Error: E = 2i for some i.  Choose G with 2 or more terms (e.g. G = 2p +1). G does not divide 2i Two-Bit Error: E = 2i + 2j = (2i-j +1)2i (with i > j).  G should include 2p + 1(to avoid the 2i term, see above)  Also, G should not divide 2i-j +1 for any (i-j=) k <= frame length  For example: G = works for frames with length <= 32768 E has an odd number of 1s:  Choose a G - as a number - that is divisible by 3

20 CRC CRC Performance (contd):
Burst Error: E = (2k-1 + … + 1).2i (E of length k). G should be odd (i.e. it ends with 1) to avoid the factor 2i Cases: k-1 < r: burst length less than length of G: Error always detected, since A mod B != 0 for any A < B and A != 0 k-1 = r: burst length equal length of G: Error is not detected iff E = G. However, because G begins/ends with 1, only the middle k-2 (= r-1) bits are decisive in this case. This constellation happens then with probability 1/2r-1 k-1 > r: burst is arbitrarily long: The length of the remainder (of E/G) is r. Hence, the probability of the error not being detected is 1/2r (remainder has r zeros)

21 CRC Hardware Implementation: Register Data Adder 100100000 remainder
Shift register of length r initialized to zero. XOR gates added between cells where there is 1 in G (except for leftmost 1) In each step, a bit is read from the message, the XOR operations activated, and then the shift operations. Our example: Adder 1 Register Data 001 remainder

22 Checksum

23 Error Correction Two methods:
Sender-based: First error detection, then ask sender to retransmit data in case of an error. Automatic or Receiver-based: Here, receiver tries to find out after an error what the correct data might have been.  Error-correcting codes In theory, it is possible to correct any detected error automatically, however, this is not done in practice, because it requires lots of redundancy (which is overhead). How many redundant bits are needed to allow for correction? Example for single-bit errors: ASCII character = 7 Bits Situations: No error, Error in 1st bit, Error in 2nd bit, …, Error in 7th bit. At first glance, we would need 3 redundant bits to perform correction. However, errors can affect the redundant bits, too.

24 Error Correction How many redundant bits are needed? (Contd)
Number of redundant bits r should be chosen in such a way that all single-bit errors, and these are m+r+1 ones, can be corrected. Since r bits can have 2r different states, a sufficient condition is: 2r >= m+r+1 For example, for ASCII code (m=7) the smallest value of r is 4: 16 = 24 >= = 12

25  r-bits are placed in positions which are power of 2.
Error Correction We now know how many redundant bits to use. The remaining question is how to use them to identify the bit in error.  Hamming code Idea: Place the redundant bits (r-bits) in different positions. Each r-bit is the parity bit (or VRC bit) for a subset of the entire data. Receiver checks the parity bits again, and can identify the bit in error (if any). Placement of the r-bits for ASCII characters:  r-bits are placed in positions which are power of 2.

26 Error Correction Details of the r-bit placement:
Let bi the binary representation of (position i). Pj the set of bits, which rj is responsible for.  Pj = {i, bi has a 1 at position j and i !=j} Our example again:

27 Error Correction Our example: (contd)

28 Error Correction Calculating the values of the r-bits (sender side):

29 Error Correction Correcting a single-bit error (receiver side):
 Assume bit 7 changed it value: received message =

30 Error Correction Burst errors:
Hamming code can correct single-bit errors. In principle, same method can be applied for burst errors, too. However, the number of the r-bits may grow prohibitively for practical use. However, there is a trick that makes Hamming code practical enough also for burst errors: Idea: 1. Use Hamming method for k data units. 2. Send those k codes column by column. 3. If |burst| <= k occurs, it would affect different codes by changing at most one bit. 4. Thus, correct data can be reconstructed, since Hamming code can correct single-bit errors

31 Data Link Layer Protocols
Main task of these protocols: Flow control: Curb (fast) sender so that it does not overwhelm receiver. Error control: Handle errors Types of flow control: Stop-and-wait: Wait for acknowledgement of sent frame prior to sending a new one.  individual acknowledgement for each frame Sliding Window: Multiple frames can be sent without acknowledgement  acknowledgement is not individual for each frame Error control: Adds error handling to protocols for flow control. Types of errors: Frame is damaged (and no correction is used or possible) Frame is lost Acknowledgement is lost Negative acknowledgement is lost (if used)

32 Data Link Layer Protocols

33 Flow Control Stop-and-Wait:
Sender waits after each sent frame until corresponding acknowledgement arrives In this way, receiver will not be overwhelmed with frames + Simple Inefficient:  transmission time doubled  Bandwidth wasted

34 Flow Control Sliding Window:
Multiple frames may be in transit at a time Window prevents sender from overwhelming the receiver More precisely: Both sender and receiver have a window with same size n. Frames are numbered modulo n+1 Acknowledgements also carry a number (mod n+1), which identifies the next frame expected by the receiver The window can hold n frames at either ends, hence at most n frames can be sent without a need for acknowledgement. Example: n = 7 Frames are numbered mod 8 e.g. If receiver sends ACK 5, the sender would understand that all frames up to number 4 have been successfully received.

35 Flow Control Sender Sliding Window:
Assume data are fed (by network layer) from the right, then: Sender window shrinks from the left when frames are sent Sender window expands to the right when acknowledgements are received Example: If frame 0, 1, 2, 3, 4 have been sent  W = {5, 6} If ACK 4 arrives later  W = {5, 6, 7, 0, 1, 2} to physical layer from network layer

36 Flow Control Receiver Sliding Window:
Assume data are fed (by physical layer) from the left, then: Receiver window shrinks from the left when frames are received Receiver window expands to the right when acknowledgements are sent Example: If frame 0, 1, 2, 3, 4, 5 have been received  W = {6} If ACK 2 has been sent  W = {6, 7, 0} If ACK 5 has been sent  W = {6, 7, 0, 1, 2, 3} (new win size = old win size + (current ACK# - previous ACK#) mod 8) from physical layer to network layer

37 Flow Control: Example

38 Error Control Idea: Integrate error handling with flow control.
Error control refers mainly to methods of error detection and retransmission. Error control is based on ARQ (Automatic Repeat Request). ARQ policy: On error detection, send NAK and let sender retransmit a frame. Sender uses in general a timer to detect errors (lost ACK/NAK). Again, errors are: corrupted frame, lost frame, or lost ACK/NAK Classification:

39 Error Control Stop-and-Wait ARQ: Error handling:
Simple Stop-and-Wait flow control + retransmission in case of errors Rules for retransmission: Sender keeps copy of last transmitted frame until an ACK arrives Both data frames and ACK are numbered alternatively 0 and 1. For example, ACK1 means that receiver accepted data frame 0 and is expecting data frame 1. If an error is detected in a frame, a NAK is send by receiver. NAKs are not numbered and tell sender to retransmit last frame. Sender uses a timer, after a timeout (without ACK) sender retransmits last frame. Error handling: Damaged frame Lost frame Lost ACK/NAK

40 Stop-and-Wait ARQ : Damaged Frame
Example for a damaged frame 1 Error in frame 0 Retransmission

41 Stop-and-Wait ARQ: Lost Frame
ACK 0

42 Stop-and-Wait ARQ: Lost ACK/NAK
ACK 0 Second copy discarded ACK 0

43 Sliding Window ARQ New Features (added to basic sliding window flow control): Sender keeps copies of frames which are not acknowledged yet. In addition to ACK receivers uses also NAKs. Both are numbered: ACK carries the number of next frame expected. NAK carries the number of the damaged frame itself (which is the expected one). Examples: If last ACK was numbered 4, an ACK 7 means that frames 4, 5, and 6 have been received correctly. If frame 8 and 9 were damaged, both NAK 8 and NAK 9 are returned, but NAK 8 tells sender that previous frames were intact. Sender has a timer. Since n (window size) frames can be sent without acknowledgement, sender starts the timer after sending n frames if their ACK is still missing. On timeout, sender resends one/multiple frames (depending on protocol). Receiver must be able to recognize duplicates. Two protocols: Go-Back-n ARQ and Selective Reject ARQ

44 Go-Back-n ARQ Idea: If frame is lost/damaged all frames since the last ACK are resent. Damaged frame: Resent Resent Resent

45 Receiver detects 2 is skipped
Go-Back-n ARQ Lost frame: Receiver detects 2 is skipped Resent Resent Resent

46 Go-Back-n ARQ Lost ACK: Sender has to send 3 frames only
(otherwise window size is decisive) Resent discard Resent discard Resent discard ACK 3 Resent

47 Selective Reject ARQ Idea: Requirements:
Resend only the specific lost/damaged frame. If NAK is returned, sender retransmits only specified frame (out of sequence). This means that receiver must be able to sort frames and insert a retransmitted frame in its proper place in the sequence. Requirements: Receiver should have a sorting logic to enable to reorder frames received out of sequence. Receiver must be able to store frames after a NAK has been sent until the damaged frame has been replaced. A buffer in the receiver must keep all frames until all retransmissions have been sorted and any duplicate frames have been identified and discarded. To aid selectivity, ACK numbers, like NAK numbers should refer to the frame received (or lost) instead of the next frame expected. Sender must have a searching logic that allow to find and select the frame to be retransmitted. For efficiency, window size is recommended to be less than or equal 1+n/2 where n is the Go-Back-n window size.

48 Selective Reject ARQ Damaged frame:
Receiver accepts further frames but must not return an ACK until frame 2 is retransmitted ACK 5

49 Receiver detects 2 is skipped
Selective Reject ARQ Lost frame: If frame 2 was last frame, sender treats this case as a lost ACK Receiver detects 2 is skipped Data 3 NAK 2 Resent Data 2 Data 4 Data 5 Data 2 Data 5

50 Selective Reject ARQ Lost ACK/NAK: Like in Go-Back-n.
When sender reaches capacity of window or the end of its transmission, it sets a timer. If after timeout no ACK arrives, sender retransmits all frames that are not acknowledged yet. Receiver should recognize duplicates and discard them. Go-Back-n vs. Selective Reject: Communication overhead: Go-Back-n > Selective Reject Logic complexity: Selective Reject > Go-Back-n However, in practice Go-Back-n is used more often (due to its simplicity). Remark: Note that stop-and-wait is a special case of the sliding window protocol with a window size of 1.

51 High-Level Data Link Control
HDLC: Origin: IBM mainframe protocol SDLC (Synchronous Data Link Control) Various variants: ANSI: ADCCP ISO: HDLC CCITT: LAPB Bit-oriented protocol (not character-oriented) Bit stuffing for transparency and sliding window (n=7) for flow control. Point-to-point links and multi-point links (e.g. computer with different terminals) Structure of a frame: Frame delimiter Only for multipoint links (e.g. terminal id) Sequence number, ACKs, … Actual data CRC

52 HDLC: Control Field 3 Types: information (a), supervisory (b), and unnumbered frame (c) Information frame: Seq: sequence number Next: piggybacked ACK (next expected frame) if there is reverse traffic. P/F: Poll/Final bit; used if computer asks terminal to send data (P-frame). Terminal replies with P-frames except the last one is an F-frame. Supervisory frame: Type 0: ACK, Next= expected frame, used piggybacking not possible. Type 1: NAK, Next=frame in error, sender resends all outstanding frames. Type 2: ACK + asking sender to temporarily stop sending. Type 3: Receiver asks sender to resend specified frame (in Next). Unnumbered frame: No common use of it, but it may include information like: - Disconnect/connect machine - Fame has impossible semantics - ACK for control frames


Download ppt "Chapter 3 The Data Link Layer."

Similar presentations


Ads by Google