Comp 346/488: Intro to Telecommunications

Tuesdays 7:00-9:30, Lewis Towers 412

Class 5: Sept 28

Chapter readings (7th-9th editions):
    8.1, 8.2
    10.1-10.5
   

Homework 1, due Oct 5
See week 4 for details

MULTIPLEXING

Brief note on synchronous v asynchronous transmission (§6.1)

Sender and receiver clocks MUST resynchronize at times; otherwise, the clock drift will eventually result in missed or added bits.

Asynchronous: resynchronise before/after data, eg with a "stop bit" before and after each byte. This is common approach with serial lines, eg to modems.

Synchronous: send data in blocks too big to wait to resynchronize at the end, but embed synchronization in the data (with NRZ-I, for example, we usually resynchronize on each 1-bit).

Manchester (a form of synchronous): interleave clock transitions with data transitions.

More efficient techniques make sure there are enough 1's scattered in the data itself to allow synchronization without added transitions. Example: 4b/5b: every 5 bits has at least 2 transitions (2 1-bits)


Brief note on PACKETs

The IP model, with relatively large (20 byte for IP) headers that contain full delivery information, is an approach allowing a large and heterogeneous network. But simpler models exist.

The fundamental idea of packets, though, is that each packet has some kind of destination address attached to it. Note that this may not happen on some point-to-point links where the receiver is unambiguous, though what "flow" the packet is part of may still need to be specified.

HDLC example (Highlevel Data Link Control), §7.3


Simplest: 8-bit address, 8-bit control containing two 3-bit sequence nums.

HDLC is a good example of a link-level protocol. Note the small number of sequence-num bits, because reordering cannot occur. Also, the address field is small, because there are only a small number of hosts on a single link.

Modes:
Packet format:

flag
8 bit
 addr
8 bit
 control
8 or 16 bit
 data
 CRC
16/32 bit
 flag
8 bit


Note the lack of a return address

The flag field is the bit pattern 0111 1110.

Bit stuffing, used to make sure the flag pattern does not appear in the data.

Addressing: nominally 8 bits, really only 7. Extended addressing can use 14, 21, 28 bits of address. The first bit of each byte is 0 if there are more address bytes following, 1 for the last address byte.

Control
8-bit control fields use 3-bit sequence numbering; 16-bit uses 7-bit numbering. Note that on a link, packets cannot reorder, so the numbering need only be twice the size of the sliding window (brief discussion of sliding-window algorithm).

1st bit is 0 for information (data) packtes, 1 for supervisory/unnumbered.

Important packet formats:
Fig 7.9

Comparison to TCP/IP

IP address size, header format
IP environment

TCP is end-to-end, not link
3-way handshake


8.1: FDM (Frequency Division Multiplexing)

AM radio is sort of the archetypal example.
Frequency v time: fig 8.2

ATT "L-carrier" FDM
voice example (fig 8.5):
4kHz slots; 3.1kHz actual bandwidth (300 Hz - 3400 Hz). AM SSB (upper sideband) modulation onto a carrier frequency f transforms this band into the band [f, f+4kHz], of the same width. Note that without SSB, we'd need double the width; FM would also use much more bandwidth than the original 4kHz.


ATT group/supergroup hierarchy: Table 8.1

name
 composition
 # channels
Group
12
Supergroup
 5 groups
 5 × 12 = 60
Mastergroup
 10 supergroups
 10 × 60 = 600
Jumbogroup
 6 mastergoups
 6 × 600 = 3600
Mastergroup Multiplex
 N mastergroups
 N × 600

L-carrier: used up through early 1970s

Why bundle calls into a hierarchy of groups? So you can multiplex whole trunks onto one another, without demuxing individual calls. Peeling out a single call is relatively expensive, particularly if we want to replace that slot with a new call. For one thing, additional noise is introduced.

Even the repeated modulation into larger and larger groups introduces noise.

Chapter 8.2: STDM (Synchronous Time-Division Multiplexing)

Fixed-width interleaving, of N low-datarate channels onto one high-datarate line in the course of one frame, each sender gets one timeslot (usually equal-sized). 1 frame = N timeslots

Timeslots are SMALL (eg 1 byte), and have no addressing or headers.

Input channels are assumed continuous: senders send pad bytes if nothing else. (Note that in realtime voice transmission, pad bytes represent silence, but still need to be transmitted to maintain timing.) Encoding and decoding are simple; no addressing is needed!!

Timeslots are typically very small: 1 byte or even 1 bit (DS1 uses 1 byte)
T1 example: 1544kbps. Frame size: 193 bits, = 24 timeslots of 8 bits each, + 1 "framing" bit
Rate is 8000 frames/sec, for 8 × 193 = 1544 bits/msec (1.544 mbps).

All we need is a 1-byte buffer for each input channel; these are sampled round-robin. Some input channels can get 2 or more timeslots; buffering is only slightly complicated. Synchronous here is used to refer to the fact of preassigned timeslots


T1 / DS1 lines
(T1 = physical level, DS1 = logical signaling level; B8ZS is the physical signaling used.)
Framing bit (T1 lines: one framing bit for every 24×8 = 192 data bits)
12 frames = 1 superframe, special 12-bit pattern encoded in the 12 framing bits (maybe 010101 010101). These lines were used starting mid-1970s for trunking.

The main advantage over FDM is no cumulative distortion

24×64 = 1.536 mbps, DS1 = 1.544; diffference is 8kbps

4 × 1.544 = 6.176 Mbps; DS2 = this plus 136Kbps = 2×64kbps + 8kbps

framing-search mode: used for initial synchronization and when synchronization is lost. We know a frame is 193 bits; we examine every bit of each frame until we find one bit that consistently shows the framing pattern 0,1,0,1,0,1,....

voice data:
every-sixth-frame signaling bits
5 frames of 8-bit PCM, one frame of 7-bit plus a signaling bit (7-bit PCM here just means stealing the low-order bit for signaling, and setting it to 0 on delivery). This is why modems just get 56kbps, not 64 kbps.

digital mode: 8th bit in every byte is an indicator of user data v control; lots of room for stuffing but with 8/7 overhead.
digital mode sync byte

Full-line digital mode: use 23 bytes per frame for data; 24th byte is used for framing indicator that allows faster recovery than the 1-bit-per-frame method.

What if one of the inputs runs slow?

naive outcome: we will duplicate a byte every now and then, from the slow source. Ultimately, there is no easy fix. But it is easy to send packets over a single TDM channel! Just pre-buffer!

pulse stuffing: extra capacity in outbound link. We need either applications that will tolerate occasional bad data (voice) or else we need some way of encoding where the extra bits/bytes have been put

Table 8.3: North American DS-N hierarchy

DS0
 64kbps voice line
DS1
 1544 kbps, = 8×24 + 1 = 193 = 1544/8 bits/frame
DS2
 6312 kbps, 789 b/f = 96 bytes + 21 bits = 4×DS-1 + 17 bits
Actually 1176 bits per DS2 M-frame
DS3
 44736 kbps, 5592 b/f = 24×28 bytes + 27 bytes
= 7 DS2 + 69 bits
Actual frame size is 4704 bits, rate 106.402 microseconds



  
bit-stuffing: flag bits indicate whether certain bytes have data or padding

Allowable clock drift: 2E-5, or, for a DS1, 30 bits/sec


DS1→DS2 multiplexing

Reference: http://cs.luc.edu/pld/courses/346/fall10/DS3fundamentals.pdf.

This is just plain weird. If nothing else, it should convince you that telco engineers think in bits, not bytes.

Note from Stallings (p 253 in 9th edition)
Pulse Stuffing ... With pulse stuffing, the outgoing data rate of the multiplexer, excluding framing bits, is higher than the sum o fthe maximum instantaneous incoming rates. The extra capacity is used by stuffing extra dummy bits or pulises into each incoming signal until its rate is raised to that of a locally generated clock signal. The stuffed pulses are inserted at fixed locations in the multiplexer frame format so that they may be identified and removed at the demultiplexer.

But how do you tell when a bit was stuffed, and when it was not? Variability (sometimes stuffing, sometimes not) is essential if this technique is going to allow us to "take up slack".

Here are the details for how pulse-stuffing is used to multiplex four DS1 signals onto a DS2 signal.

First, the multiplexing is completely asynchronous; we do not align on DS1 frame boundaries.

A DS2 "stuff block" is 48 bits of data, 12 from each DS1, interleaved round-robin at the bit level, plus an overhead bit at the front. (We'll revisit these OH bits below; each bit is either an M-bit, a C-bit, or an F-bit, based on position.)
An M-subframe is six stuff-blocks, holding 72 bits of each DS1, total 288+6=294 bits
An M-frame is four subframes (M1, M2, M3, M4), holding 288 bits of each DS1, total 294×4=1176

Each M-frame can accomodate up to 1 "stuff bit" per DS1 input. A stuff bit is a bit that upon demultiplexing does not belong to that DS1 stream. The DS2 output stream runs slightly fast (ie DS1 inputs are "slow"), so stuff bits always represent "missed" bits. There is no way to handle inputs running fast.

If the input buffer is running low on bits, we insert a stuffed bit to give it a chance to catch up.

Naming the overhead bits:
In each M-subframe, there are six OH bits: ⟨M, C, F, C, C, F⟩.

M0
 C
 F0
 C
 C
 F1
M1
 C
 F0
 C
 C
 F1
M1
 C
 F0
 C
 C
 F1
Mx
 C
 F0
 C
 C
 F1

There are 4 M-bits in an M-frame, spelling out the bit pattern 011x, where x varies.
The F-bits are for frame alignment; the first is always 0 and the second is always 1.

Stuffing for input stream i is done in M-subframe Mi, i<4.
If the three C-bits of that subframe (ith row) are all 1's, then the first bit of the ith input stream in the last stuff block is stuffed; ie is not real. If the C-bits are all 0's, then there was no stuffing.
Actual use: 2 out of 3 1's, versus 2 out of 3 0's. WHY WOULD WE DO THAT??? Isn't any bit error equally fatal??

Note the size of the blocks never changes.

With four DS1's, the data rate for a DS2 needed is 4×1.544×49/48 = 6.30466666.. Mbps
But the actual DS2 rate is 6.312 Mbps = 8 kbps × 789

We stuff bits as necessary to take up the slack.
total DS2 bits per second:           6312000
DS1×4 data bits per second:      -6176000
DS2 overhead bits per second    - 128816
                                                 ________
Total stuff bits:                                 7184
Divided by 4:                                   1796 bps per DS1

At 8000 frames/sec, that's roughly 1 stuff bit every 4.5 frames, or 1 bit every 860 bits.

DS2→DS3: Same strategy is possible, except nowadays this is generally done as an integrated process multiplexing 28 DS1's into a DS3. So the DS3 stuff bits are never needed (all the slack is taken up at the DS1→DS2 level), so they've been adopted for line-signaling purposes.


SONET

First look at SONET hierarchy: Table 8.4
STS-1/OC-1
51.84 Mbps
STS-3/OC-3
 STM-1
 155.52 Mbps
STS-12/OC-12
 STM-4
 622.08 Mbps
STS-48/OC-48
 STM-16
 2488.32 Mbps
STS-192/
 STM-64
 9953.28 Mbps
STS-768
 STM-256
 ...

STS = Synchronous Transport Signal
OC = Optical Carrier

Note that each higher bandwidth is exactly 4 times the previous (or 3 for the first row). There is no stuffing.

basic SONET frame
Actually, 3 path-overhead columns. Total data columns: 84


STS-1: 810 bytes × 8 bits/byte × 8 frames/ms = 51840 b/ms

STS-3: exactly 3 STS-1 frames