Outline

• Finish Encoding
• Framing
• Quiz
• Error Detection/Correction

4B/5B encoding

• In 4B/5B encoding, every 4 bits of data are encoded in a 5-bit code sent to the receiver (who must then decode them).
• These codes are sent using NRZI.
• The 5-bit codes are selected such that each one has no more than one leading 0 and no more than two trailing 0s.
• So when sent back-to-back, no pair of 5 bit codes results in more than three consecutive 0s.
• The bit rate/baud rate efficiency of the code is 80% -- so is better than Manchester encoding.
• The book has a table of the 5-bit codes. For instance, 0000 maps to 11110.
• There are 32, five bit strings, 16 are used for data, 7 are not valid, and six are used for control values. One also has 11111 -- line is idle, 00000 - line is dead, and 00100 -- halt.
• 4B/5B is used by FDDI optical ring networks which we'll descibe later, it is also used by Fast Ethernet.
• There is also a 8B/10B scheme which uses the same idea applied to 8 versus 10 bits used by PCI Express and Firewire, and a 64B/66B scheme used by 10GB Ethernet.

Framing

• Let's assume we can now send a sequence of bits over a link.
• Since we will be focussing on packet-switched networks, we are interested now in splitting this bit-stream into blocks of data called frames.
• We will first look at this problem for point-to-point links and then for multiple access networks.

Byte-oriented Protocols

• A protocol which views each frame as a collection of bytes rather than bits is called a byte-oriented protocol.
• Such protocols were originally developed to connect terminals to a mainframe.
• For example, Binary Synchronous Communication (BISYNC) was developed at IBM and Digital Data Communication Message Protocol (DDCMP) was developed at DEC for this purpose.
• Point-to-point (PPP) is a more recent and widely used example of this approach.
• We'll now discuss two types of byte-oriented framing: sentinel-based framing and byte-count framing.

Sentinel-based Framing

• BISYNC uses special characters called sentinel characters to indicate where frames start and end.
• The SYN character is used to indicate the start of a frame, there is a SOH character to indicate a start of a frame header, an STX character to indicate start of text, and an ETX character used to indicate the end of text.
• A BISYNC frame ends with a CRC (cyclic redundancy check) character used to detect errors in the frame.
• BISYNC uses character stuffing (preceding a control character with a special data-link escape (DLE) character) if a SYN, ETX, etc need to appear in the text or header.

PPP Frames

• PPP is commonly used to carry internet packets over point-to-point links (could be modem; could be long-haul links).
• It was defined in RFC 1661
• Flag is a sentinel with bit pattern 01111110; Address and Control usually contain default values 0xFF and 0x03; Protocol is used to identify the high level protocol such as IP or IPX(Novell).
• The Payload can be up 1500 bytes and character stuffing might be used in it.

Link Control Protocol

• The Protocol field is negotiated using the Link Control Protocol (LCP).
• LCP actually makes use of PPP frames to send control messages to do this negotiation. These messages have as their protocol a special LCP identifier.
• LCP is also used to establish a link between peers when both sides detect that communication over the link is possible.

Byte-count Framing

• In the byte-counting approach, one sends the number of characters in the frame at the start of the frame.
• DDCMP uses this approach. Its frames look like:

  8 bits	8 bits	8 bits	14 bits	42 bits		16 bits
  SYN	SYN	Class	Count	Header	Body	CRC

• So called framing errors occur with both byte-count framing and sentinel framing if the COUNT field is incorrect or the ETX field is corrupted. These can be caught using the CRC field.

Bit-oriented Protocols (HDLC)

• The high-level data link control protocol (HDLC) is an example of a bit-oriented protocol -- the payload of a frame is viewed as a sequence of bits which might not necessarily corresponds to bytes in some character encoding.
• HDLC is an ANSI and ISO standard derived from the SLDC -- Synchronous Data Link Control protocol used in IBM mainframes.
• A HDLC frame looks like:

  8 bits	16 bits		16 bits	8 bits
  01111110	Header	Body	CRC	01111110

Bit-stuffing

• If the beginning sequence 01111110 is needed within the body of the message a technique known as bit-stuffing is used:
  • Whenever 11111 is sent within a frame, the sender immediately sends a 0, before sending the next bit.
  • The receiver when receiving these extra 0's immediately removes them from the decoded bit stream.
• Notice for both bit-stuffing and character stuffing, the size of the frame depends on what is being sent.

SONET and Clock-based Framing

• Sychronous Optical Networks (SONET) use a third approach to framing known as clock-based framing.
• SONET was developed at Bell Communication Corporation, ANSI, and it has been adopted by the ITU-T.
• SONET solves both the framing and encoding problem and it also supports multiplexing several low-speed links onto higher speed links.
• In SONET a frame is sent every 125μS whether or not one has data. Frames are sent based only on the clock so are synchronous.
• One kind of traffic we'll later consider over SONET is called ATM. ATM cells do not arrive based on a clock, so the A in ATM stands for asynchronous.

SONET STS-1 Frames

• An STS-1 frame consists of 9 rows each of 90 bytes.
• The first 3 bytes of each row are overhead, but the remaining "payload" bytes can be used for data.
• The first three rows of overhead data are called the section overhead. Section overhead is checked at the start of each section (frame).
• As an example the first two bytes of each frame (first two overhead bytes of first row, i.e., section overhead) contain a special bit pattern.
• To sync itself with the sender, the receiver looks for this bit pattern repeating every 810 bytes.
• The last six rows of overhead bytes are called line overhead. They are checked each line rather than each frame.

More on SONET Frames

• The overhead bytes are encoded using NRZ.
• The payload bytes are encoded by XORing them against a fixed known 127 bit pattern that has plenty of 1's and 0's in the hope of reducing the number of all 1 or all 0 stretches in the sent data.
• In SONET, a frame is always 125μS for all STS-N. So an STS-N which is N higher transmission rate can carry a payload which is N times bigger than an STS-1 frame.
• An STS-N frame can be built out of N, STS-1 frames by interleaving the bytes of these frames. This results in an even offsets of bytes for a particular STS-1 sub-frame and allows the subframe to be de-multiplexed more easily
• The payload of a frame need not be contained completely within the frame or start at the start of a frame.
• This is useful because no matter what we have to send SONET frames every 125μS; however, an ATM cell might arrive after we have begun sending a dummy SONET frame without useful data.
• The line overhead bytes can be used to specify a synchronous payload envelope which is an offset to the starting position of the payload within a frame. This payload could potentially cross frame boundaries.

Quiz

Which of the following is true?

1. ifconfig can be used to find the route between two machines on the internet
2. A device driver might be used to write to the control status register of a network adaptor.
3. Manchester encoding achieves a bit rate/baud rate of 75%

Error Detection

• So far we know different ways to encode 0 and 1 onto low and high signals, and we know techniques to figure out when frames start and end.
• One problem we still need to solve is how to handle bit errors in frames.
• As we saw many of the frame formats of today either had checksums or CRCs (cyclic redundancy checks). These are used to detect errors in frames.
• There are two ways one could handle bit errors in frames: (1) One can use an error detecting code. Then if an error is detected one resends the frame. (2) One can use an error correcting code which provided not too many bits are messed up allows one to determine which bit to fix.
• We look at three error detecting codes: two-dimensional parity (used by BISYNC), checksums, and CRC (used by HDLC, DDCMP, Ethernet, and Token rings).

Two Dimensional Parity

• We will describe 2D PARITY in the context BISYNC, which used IBMs old 7-bit character encoding EBCDIC.
• First, after every 7 bits we count the number of 1's we saw in those seven bits. If this was odd we output a 1; otherwise a 0.
• For example, if we see 0101001, we would output a 1.
• This last bit is called a parity bit.
• Adding parities for each 7-bit sequence we want to send, would be called doing a 1D-parity check. This can detect any odd number of errors in the 7+1 bit sequence.
• In BISYNC, after every sixth 7 (data) + 1 (parity) = 8 bit sequences, we send a parity row. We first imagine we have a 6 row by 8 column rectangle, and for each column calculate its parity and write it to that column of the parity row.
• This is stronger than a 1D parity set-up in that we can detect any odd number of errors in either rows or columns. However, we now have 14 redundant bits for every 42 bits of data.

Internet Checksum Algorithm

• This algorithm is used at the internet/network layer; whereas, the other two detection algorithms we will consider are at the data link layer.
• As in practice most errors are caught in the data link layer the detection needed at this higher layer does not have to be as strong.
• The checksum algorithm views data as a sequence of 16-bit integers.
• The checksum maintains a sum of the integers seen in the frame as calculated using ones complement arithmetic and keeping only the lower order 16 bits.
• Ones complement is one of three common ways to represent signed integers in binary. These are:
  1. Sign and Magnitude Use the high order bit for the sign of the number, use the remaining bits for magnitude. So if working with 8-bit numbers 1100 0000 represents -64; whereas 0100 0000 represents 64. 1000 0000 represents -0 and 0000 0000 represents +0.
  2. One's Complement High order bit still represents sign, but given x to make -x one inverts each of the bits. In this scheme for 8 bit numbers, 0100 0000 is still 64, but 1011 1111 is -64. To add two numbers in ones complement, you first add the two numbers using binary addition, if when adding the high order bit you get a carry bit (a 9th bit), then you add one to the low order 8-bits. Notice adding 0100 0000 + 1011 1111 = 1111 1111 which represents -0. As a 4 bit ones complement example: If we add -5 + -3 in 4-bit 1's complement, we first add the two numbers to get a 5-bit number 10110 where the high order bit is the so called carry bit. We strip any carry bit to get 0110, and if the carry bit was on we increment the result to get 0111, which is low order 4 bits of -8 (which is the way we'd keep things in a checksum).
  3. Two's Complement. Used to solve the problem that in one's complement you can have two numbers representing 0. For example 0000 0000 and 1111 1111. In two's complement, positive numbers are the same as in one's complement, but for negative numbers one increases the magnitude by 1. So 1011 1111 is -65 in two's complement. Addition in two's complement is the same as addition of the numbers viewed as unsigned integers.