Data Link Layer

Logical Link Layer (LLC)

The LLC, also called the Data Link Control (DLC) layer is charged with handling communications between the network layer and the physical layer. The LLC accomplishes this through a two step process:

1. Take as input the network layer data.
2. Add control information (the information needed to enforce the speed limit the system and the recipient agreed to)

MAC Layer

The MAC layer is charged with moving the data it receives from the LLC to the physical layer, and moving the data it receives from the physical layer to the LLC. Typically, this layer is implemented by hardware (the computer's network interface card).

The MAC layer transports data through the following process:

1. Take the data as input.
2. Assemble/disassemble: If the data is coming from the LLC, attach the header and trailer frames. If the data is coming from the physical layer, assemble the frames into data (the framing service).
3. Transport the frames/data.

Alongside framing, the MAC layer also handles error control. What kind of errors is the MAC layer handling? To answer this question, we examine the process of framing.

Fixed-size Framing

Here's how fixed-size framing works: Before any data is exchanged between ${A}$f and ${B,}$ they mutually agree that the bits they exchange with one another can be organized into groups of ${x}$ bits. That is, each frame will be of size ${x.}$ Thus, when ${B}$ receives the bitstream, it will construct a frame every ${x}$ bits.

Fixed-size framing's primary benefit: It's easy to manage for the receiver and faster to process for the receiver. The receiver simply needs to keep track of how many bits its read, and reset that count everytime it hits ${x.}$

The costs: It can lead to substantial wasted space because of the fixed size. If a chunk of data only takes up 1 byte in reality but ${x = 2}$ bytes, an additional byte must be added to the frame as padding. Inversely, if a chunk of data should ideally be treated as 2 bytes and ${x = 1}$ byte, then the chunk must be split into two separate frames. This leads to increased fragmentation, which increases the risk of packet loss and corruption. Because of these costs, network engineers developed an alternative: variable-size framing.

Variable-size Framing

Here's how variable-size framing works: Before any data is exchanged between ${A}$ and ${B,}$ both ${A}$ and ${B}$ must agree on a sequence of bits (called a sentinel) that marks the start and end of frame.

There's a problem here: The substantive data itself contains the sentinel 11011. How does ${B}$ know which 11011s are sentinels and which are substantive data? The two most common approaches to resolving this problem are bit stuffing and byte stuffing.

Clock-based Framing

Clock-based framing drastically departs from fixed- and variable-size framing. This approach essentially asks: Why should we frame according to the transferred data? Why not just use an external clock? The idea is, instead using some fixed length or sentinels, we use a clock that samples frames at specific intervals. Because the frames arrive at ${B}$ at equidistant points in time, ${B}$ can readily determine what's a frame and what isn't. ${A}$ and ${B}$ can take a clock-based framing approach by following a clock-oriented protocol like SONET (Synchronous Optical Network).

The problem with clock-based framing: It's very expensive and tricky to implement. Clock-based framing requires designers to account for delays due to relativity. It's akin to running a hybrid lecture where some students are in-person, while others are on the moon. The students in-person will hear the lecturer at the same time, but those on the moon will hear the lecturer some time ${t}$ later. This makes routine tasks difficult. Those on the moon might respond to questions that were asked and answered a few minutes ago.