How Wireless Closes the Loop: CSMA/CA and Its Limits

CS176C — Advanced Topics in Internet Computing

Arpit Gupta

2026-04-16

Part 1: How Wireless Closes the Loop

CSMA/CA, the Distributed Coordination Function (DCF), and the Failure Modes of Local Sensing

Where We Left Off

Last lecture: the assumption cascade hit a physics wall.

ALOHA → Slotted ALOHA → CSMA → CSMA/CD: each generation added shared state, shrank the vulnerable window
Wireless can’t do CSMA/CD — own signal at the antenna is 50 dB stronger than any incoming signal → receiver is deaf while transmitting
Generative exercise: when \(\tau \gg T\), sensing is useless → satellite reaches for TDMA (centralized), underwater is stuck near ALOHA (no controller)

Today’s question: WiFi sits between those extremes. \(\tau \ll T\) on a LAN, so sensing works. But CD doesn’t. How does wireless close the feedback loop without it?

Then: how that loop scales under density — and what finally broke it.

Spend no more than 90 seconds here. The goal is to re-anchor on where L5 actually ended, not to re-teach.

Students walked out of L5 holding two threads: (1) wireless physics rules out CSMA/CD; (2) when sensing breaks down entirely, you either centralize (satellite TDMA) or regress (underwater ALOHA). Today we plant WiFi between those two extremes — sensing still works locally, but the missing CD has to be replaced by something.

The pedagogical move: the feedback loop is the unit of analysis. CSMA/CD’s loop closed in 51.2 µs (the bit-times of a max Ethernet segment). What is the equivalent for wireless? That is the question students will answer in the next few slides. Once we have CSMA/CA, we trace its failure modes (hidden/exposed terminals, density collapse), then in Part 2 we ask what replaces it.

CSMA/CA: The Principle

L5 left you here: you can listen before transmitting, but you cannot listen during. So you never directly observe a collision.

30 seconds with your neighbor: what’s the simplest protocol that still closes the loop?

Three steps, nothing more:

Sense before transmitting — if busy, wait; if idle, go.
Transmit the whole frame (you can’t detect mid-frame anyway — so send it all).
Wait for an acknowledgment (ACK) from the receiver. No ACK → assume collision → wait a random time, retry.

That’s it. This is CSMA/CA — Carrier Sense Multiple Access with Collision Avoidance.

The loop closes at the receiver, not the transmitter. The ACK is the only signal available.

This is the pivot slide of Part 1. One job: land the three-step principle.

Walk through it:

“L5 told you wireless can’t sense its own signal vs. an incoming signal — your antenna saturates. Collision detection is impossible. So how do you even know if your frame got through?”
Give them 30 seconds. Most will say “ask the receiver” or “wait for an ACK.” That’s the right answer. Don’t rush past it — let them feel the inevitability. The ACK is not a design choice; it’s the only signal available.
State the three steps crisply. No SIFS/DIFS/BEB/NAV yet — those are enhancements students will derive later from specific challenges.
The cost of this design is that the sender must finish the whole frame before any feedback is possible — the loop is frame-time-bounded rather than propagation-bounded like CSMA/CD. We will quantify that in the next slide.

Instructor history (for your reference, do NOT put on slide): the principle coalesced in the early 1990s — Karn’s MACA (1990, handshake only), MACAW (1994, added link-layer ACK), Apple LocalTalk (1985, commercial precedent). 802.11 DCF (1997) packaged the final form with efficiency refinements. Mention only if students ask.

How Long Do We Wait for the ACK?

You transmit a frame. You listen for an ACK. How long do you wait before giving up?

The wait must cover:

Frame TX time: \(T_{\text{frame}} = \frac{\text{frame size}}{\text{bit rate}}\)
ACK TX time: \(T_{\text{ACK}} = \frac{\text{ACK size}}{\text{bit rate}}\)
Radio turnaround + margin: tens of µs

. . .

At 802.11b’s 1 Mbps basic rate, 1500-byte frame:

\[T_{\text{frame}} = \frac{1500 \times 8 \text{ bits}}{10^6 \text{ bits/s}} = 12 \text{ ms}\]

\[T_{\text{ACK}} = \frac{14 \times 8 \text{ bits}}{10^6 \text{ bits/s}} \approx 0.1 \text{ ms}\]

Per-attempt loop: ≈ 12 ms — dominated by frame TX.

Compare to CSMA/CD on Ethernet:

Loop closes in 51 µs (propagation round-trip on max segment)
Ethernet is propagation-bounded
CSMA/CA is frame-time-bounded

. . .

Ratio: 12 ms / 51 µs ≈ ~250× slower per attempt.

. . .

Why the gap? Not propagation delay (WiFi prop. delay is microseconds at 100 m range). The sender must finish the whole frame before the receiver can even start an ACK — L5’s physics made that unavoidable.

This is the core fragility of CSMA/CA. Ethernet’s tight loop tolerates ~95% load. WiFi’s loose loop can’t — we’ll see the ceiling later in the lecture.

This slide answers the ACK-wait question using ONLY pure CSMA/CA — no SIFS, no DIFS, no BEB. The number comes from a single calculation: frame size divided by bit rate.

Key pedagogical points to drive home:

Propagation delay is not the bottleneck in wireless. For a 100-meter indoor AP cell, one-way propagation delay is ~333 ns — three orders of magnitude smaller than even ACK TX time. The feedback loop is bounded by frame TX time, not signal travel time.
Ethernet vs. WiFi comparison is physically asymmetric. Ethernet’s 51 µs is literally the round-trip of a signal on a 2500 m cable. WiFi’s 12 ms is literally the time to push 12000 bits at 1 Mbps. These are different quantities bounded by different physics.
The 250× ratio is defensible and derivable. It comes from one number: (1500 bytes × 8 bits) / (1 Mbps) = 12 ms. Contrast with the “1000× slower” claim from the previous version of the slides — that was not cleanly derivable.
Do not cite “50 ms” as an ACK timeout. The pre-DCF CSMA/CA literature has no such number. Numbers that DO appear: ACK timeout ≈ 200–300 µs in early 802.11 (DCF-era spec field, not the feedback-loop period). If students ask about the “~50 ms feedback loop” they may have heard elsewhere, explain: that number arises under saturated contention with BEB at CW_max on legacy FHSS (1023 × 50 µs ≈ 51 ms). That’s a worst-case backoff wait under DCF’s enhancements — not a pre-DCF CSMA/CA number.

Forward-plant: “12 ms per attempt is already much worse than Ethernet. What happens when things go wrong and you need to retry? What can go wrong?”

What Goes Wrong? CSMA/CA’s Four Challenges

You have CSMA/CA working. Now stress-test it. Turn to your neighbor — 2 minutes: what failure modes can you find?

Listed in the order history recognized them:

1. Hidden terminal (recognized 1975). L5’s environment-vs-measurement gap: station A senses “idle” at A’s antenna, but C (hidden from A) is transmitting to B. Collision at B’s receiver.

2. Backoff collisions repeat (addressed 1994, MACAW — “MACA for Wireless”). Two stations collide. Both retry. If they pick the same random wait, they collide again. How do you prevent cascading retries?

3. ACK is vulnerable to new attempts (addressed 1997, 802.11 DCF — Distributed Coordination Function). After a frame, the receiver sends ACK. But other stations were waiting too — they may try to transmit the moment the medium clears. ACK collides with a new-attempt frame.

4. Density collapse (quantified 2000, Bianchi). As \(n\) stations grow, the probability of two picking the same wait approaches 1. Even perfect random avoidance breaks down at scale.

Next: we’ll take each in turn, starting with the oldest — hidden terminals, 1975.

This slide is the roadmap for the rest of Part 1. Students should walk out of it knowing:

The four challenges exist and are distinct. Each has a different root cause and a different fix. Confusing them (as earlier slides in this deck did) obscures the reasoning.
Chronological order of recognition and response:
- Hidden terminal — Tobagi & Kleinrock recognized it in 1975, well before CSMA/CA formalized. Busy tone (1975) proposed, Karn’s RTS/CTS (1990) reformulated in-band.
- Backoff collisions + repeated retries — solved by binary exponential backoff (BEB). Origin in Ethernet (1976), adopted in MACAW (1994) and 802.11 DCF (1997).
- ACK vulnerability — solved by priority-via-timing (SIFS < DIFS). Specific to 802.11 DCF (1997).
- Density collapse — quantified by Bianchi in 2000, showed CSMA/CA caps at ~30% under saturation. This is the motivator for the rest of the lecture (WiFi evolution + cellular).
Why this ordering matters pedagogically. Students reason from the problem to the solution. If you present “SIFS = 16 µs” as a fact, it’s arbitrary. If you present “we need a mechanism to protect ACKs from new attempts,” then “shorter wait = higher priority” falls out naturally, and SIFS is the realization.

Let students try to propose solutions before moving on. Most will arrive at “make the contention window bigger after collisions” (→ BEB), “give ACKs priority” (→ SIFS/DIFS), “ask the receiver first” (→ RTS/CTS), and “scaling is hard” (→ density).

Transition: “Let’s take these one by one, in the order history took them — starting with the oldest-recognized problem.”

Tobagi & Kleinrock (1975): Discovering the Limits of CSMA

→ Addressing Challenge 1 (hidden terminal). Chronologically the oldest of the four — recognized in 1975, 15+ years before CSMA/CA as a principle.

The setting: UCLA’s Packet Radio Network (PRNET) experiments — applying Kleinrock’s CSMA to terrestrial radio. Throughput was much worse than the LAN model predicted.

Their diagnosis (“Packet Switching in Radio Channels, Part II”):

Hidden terminal — sensing too optimistic:

   A ←──range──► B ←──range──► C
   A and C cannot hear each other
   Both transmit to B → collide at B

A and C each sense “idle.” Both transmit. Frame destroyed at B. Neither learns why — only an ACK timeout.

Exposed terminal — sensing too conservative:

  A ←──range──► B    C ←──range──► D
                  ↑    ↑
                  └────┘   C hears B

C defers to B’s transmission to A. But C → D wouldn’t have hit B → A. Airtime lost.

Tobagi & Kleinrock’s framing: carrier sense at the transmitter is the wrong measurement. The collision is determined at the receiver. Until measurement reaches the receiver, no amount of backoff cleverness will close the gap.

This is the canonical pioneer reference. Tobagi was Kleinrock’s PhD student at UCLA in the early 1970s, working on the SUR (Survivable Radio Network) and PRNET projects. His 1974 dissertation and the follow-up papers (Tobagi & Kleinrock 1975, “Packet Switching in Radio Channels, Part II — The Hidden Terminal Problem in Carrier Sense Multiple-Access and the Busy-Tone Solution,” IEEE Trans. Comm.) are where these problems were first named and analyzed.

The historical context matters: Kleinrock’s original CSMA analysis (1975, with Tobagi for Part I) assumed all stations could hear each other — the LAN/single-hop model. When PRNET tried to apply CSMA to multi-hop terrestrial radio, throughput collapsed. Tobagi traced the cause analytically and identified the two failure modes.

The naming order matters. “Hidden terminal” was named and analyzed in Tobagi-Kleinrock 1975. The “exposed terminal” concept appears on this slide as the dual case for completeness, but its formal attribution in the literature is less clean — commonly associated with the MACA/MACAW era (1990-94), not the 1975 paper. Do not assert that both problems were named together in 1975.

The deep observation — and the one that makes this a pioneer slide rather than just a textbook slide — is that they identified the structural issue, not just the mechanism. The collision happens at the receiver; the measurement happens at the transmitter; these two locations are different points in space. No improvement to CSMA’s backoff or threshold can fix this. The fix has to change what is measured and where.

This framing — “measurement happens at the wrong place” — is the lens that makes Karn’s 1990 work make sense. Karn was solving the same problem with constraints Tobagi didn’t have.

Push: “Tobagi and Kleinrock didn’t just observe the failure — they identified the structural cause. That diagnosis is what made the next 15 years of fixes possible.”

Their Original Fix: Busy Tone (1975)

Tobagi & Kleinrock’s proposed solution: Move the measurement to the receiver — literally.

The Busy-Tone Multiple Access (BTMA) idea:

Allocate a second narrow channel (the “busy tone”)
Whenever a receiver is receiving a frame, it transmits a continuous tone on that channel
Every potential transmitter senses both the data channel and the busy-tone channel
If either is busy → defer

Walk through it: A wants to transmit to B. A senses the data channel (clean — can’t hear C) and the busy-tone channel. B is currently receiving from C → B is emitting the tone. A hears the tone → defers. Hidden terminal solved.

This is an elegant solution. Does it have any problems? — 30 seconds.

What it requires:

A second radio per station (cost, power, board area)
Dedicated spectrum for the tone channel
Receivers transmitting continuously during reception (power drain)
Half-duplex commodity radios couldn’t do “transmit tone while receiving data”

Excellent in theory; impractical for 1980s consumer hardware. The idea sat dormant for 15 years — until someone asked: can we get the same effect without the second radio?

This slide makes Karn’s 1990 contribution legible. Without understanding what Tobagi-Kleinrock actually proposed (and why it didn’t ship), it’s impossible to see what Karn’s reformulation accomplished.

Walk students through the busy-tone mechanism carefully:

Two channels. One for data (where actual frames are sent), one narrowband for the tone. The tone is just a carrier — no data, no protocol, just “I am here.”
The receiver speaks. This is the conceptual move. In CSMA, only transmitters had voice — they sensed the channel and decided whether to talk. In BTMA, receivers also have voice — they announce “I am consuming this channel” by emitting the tone.
Why both problems are fixed. Hidden terminal: A can’t hear C (data channel) but A can hear B’s tone (busy-tone channel) → defers correctly. Exposed terminal: C hears A (data channel) but the actual receiver D is not emitting tone → C can transmit → no false defer.
The hardware barrier. Two radios. In the 1980s, packet radio used commodity ham radio gear — single transceiver, half-duplex. Adding a second radio dedicated to the tone was prohibitively expensive in cost, power, and PCB area for the consumer/amateur market. The military used something like BTMA in some PRNET deployments, but it never crossed into commercial systems.

The framework reading: BTMA physically relocates the measurement to the receiver via a separate channel. Karn (next slide) does the same thing logically via a control-frame exchange on the same channel. The conceptual content is identical; the implementation cost is radically different.

Forward-plant: “Karn’s question 15 years later: can we get the same effect without the second radio?”

Karn (1990): The Busy Tone, In-Band

→ Still addressing Challenge 1. Same problem Tobagi-Kleinrock identified 15 years earlier — a new implementation strategy.

The setting: Phil Karn, amateur packet radio (KA9Q). Hidden terminals were destroying his throughput. He had read Tobagi & Kleinrock — but commodity transceivers couldn’t do busy tone.

Karn’s question: Can we get the busy-tone effect without a second radio?

The reformulation: MACA — Multiple Access with Collision Avoidance (Karn, 1990). Replace the continuous tone with a brief control-frame exchange on the data channel itself.

Transmitter sends short Request-to-Send (RTS) to receiver: “I want to send for \(D\) µs.”
Receiver replies with Clear-to-Send (CTS), broadcast in all directions: “Go ahead — and everyone else, hold off for \(D\) µs.”
The CTS plays the role of the busy tone — but only at the start of each frame, not continuously.

The conceptual mapping:

BTMA (1975)	MACA (1990)
Continuous tone	Brief CTS frame
Separate channel	Same channel, in-band
Receiver always emits during RX	Receiver emits at start of RX
Two radios needed	Single radio, control frames

Same idea, in-band — at the cost of handshake overhead.

Karn’s name was deliberate: the “CA” in MACA originally meant the handshake itself — avoiding collisions by delegating measurement to the receiver, not the random-backoff “avoidance” that 802.11 later folded in.

MACA solves Challenge 1 (hidden terminal) — but what about the others? Turn to your neighbor — 30 seconds:

Challenge 2 revisited (backoff collisions repeat): two stations just collided in their handshakes. What stops them from colliding again on the retry?
Completing the CSMA/CA principle: MACA has no step-3 ACK after DATA. If DATA is lost to noise/fading, who notices?

MACAW (Bharghavan et al., 1994) — “MACA for Wireless”: fixes both.

MILD backoff (Multiplicative Increase, Linear Decrease) → Challenge 2 fix — adaptive window prevents cascading collisions and shares airtime fairly
Link-layer ACK after DATA → completes CSMA/CA’s step 3; µs-scale loss detection vs. TCP timeouts (seconds)
DS (Data Sending) frame → tells exposed terminals how long to defer

802.11 DCF (1997) inherits this structure, re-introduces physical carrier sensing by default, and swaps MILD for the simpler Binary Exponential Backoff (BEB) — still a Challenge 2 fix.

This slide is the conceptual climax of the pioneer arc. Three things to land:

Karn’s contribution was implementational, not conceptual. Tobagi & Kleinrock had already identified the problem and the structural fix (move measurement to the receiver). Karn’s contribution was the in-band reformulation — making the same idea work without special hardware. This is a useful pattern in systems research: the conceptual breakthrough often precedes the implementation breakthrough by a decade or more, and both deserve credit.
The cost shift. BTMA’s cost was hardware (second radio). MACA’s cost is airtime (handshake overhead). Karn explicitly traded continuous tone bandwidth for episodic control-frame bandwidth. The total channel cost is comparable in expectation, but the implementation cost collapsed from “needs custom hardware” to “needs software on standard hardware.”
The naming history. “CSMA/CA” today usually means CSMA + random backoff (avoidance via spreading attempts in time). But Karn’s original “CA” referred to the handshake — avoidance via receiver-side announcement. The two meanings coexist in 802.11. The protocol layers BOTH: physical CS + virtual CS via NAV (Karn’s idea) + random backoff (avoidance via timing).

Historical accuracy: Karn’s MACA paper had no carrier sensing at all — he believed CSMA was actively harmful in radio because the transmitter’s measurement was wrong. MACAW (1994) softened this and reintroduced lightweight carrier sense. 802.11 went further and made physical CS the primary defense, with RTS/CTS as the optional fallback for hidden-terminal-prone deployments. So 802.11’s MAC is a synthesis of Tobagi-Kleinrock (problem framing), Karn (in-band fix), MACAW (ACK + fairness), and a pragmatic engineering decision to keep CSMA’s working parts.

Forward-plant the next slide: “The CTS is a brief broadcast that creates a commitment — ‘don’t talk for the next D microseconds.’ Stations need a data structure to track that commitment. That’s NAV.”

A Gap in the Handshake: What Stations Remember

→ Completing the Challenge 1 fix. RTS/CTS solves hidden terminal only if overhearing stations know when to defer.

The scenario from slide 10: A and B exchange RTS/CTS. Station C overhears the CTS.

Turn to your neighbor — 30 seconds. C can hear B but is hidden from A (that’s why RTS/CTS was needed). The CTS is ~100 µs, then the medium goes quiet from C’s perspective — A’s DATA frame is inaudible to C.

What stops C from transmitting during A’s DATA?

The answer must be memory, not sensing. C’s carrier sense will report idle right after CTS ends — but the channel is actually busy at B’s receiver for the full data duration.

The fix (built into the CTS):

CTS carries a Duration field: “I will be receiving for \(D\) µs.”
C stores \(D\) in a countdown timer — the Network Allocation Vector (NAV).
C defers until NAV expires, regardless of what its antenna hears.

A: [RTS|D=500µs]──────[DATA]────────
B:           [CTS|D=480µs]──────[ACK]
C: ─── hears CTS ──[NAV=480µs: defer]─
D: ─── hears RTS ──[NAV=500µs: defer]─

Two kinds of “channel busy” now coexist:

Kind	Source	Updated
Physical CS	Antenna energy	Continuously
Virtual CS (NAV)	Overheard Duration field	At handshake

A station defers if either says busy.

. . .

The conceptual shift: medium-occupancy state is no longer purely measured from physics. It is partly announced via the protocol and remembered locally as a timer.

A new kind of state — forward-looking, trust-based, and local to each station.

This is the conceptual heart of RTS/CTS — the part most textbooks skip. NAV is a fundamentally different kind of state than physical carrier sense. Three differences worth landing:

Source of truth. Physical CS samples the antenna; NAV reads protocol fields. The first is bottom-up (physics → measurement); the second is top-down (protocol announcement → defer).
Temporal nature. Physical CS reports “busy now”; NAV asserts “busy until time T”. Physical is reactive, NAV is predictive. NAV is essentially a soft reservation made via overheard control frames.
Trust model. NAV requires stations to trust the Duration field. A misbehaving station could set Duration = 32767 µs to lock everyone out (this is a known DoS vector). Physical CS has no equivalent trust dependency. So NAV trades robustness for measurement reach.

Frame the framework reading explicitly:

State invariant: State is now layered. Physical-medium state (measured) + virtual-medium state (announced). The system carries more state than pure CSMA, with corresponding gain in measurement reach.
Time invariant: A new kind of time appears — the reservation horizon (Duration field). Time is no longer purely “now,” it includes “future committed.”
Coordination invariant: Coordination is still distributed but now uses explicit announcement rather than only sensing. A small step toward centralization, foreshadowing trigger frames in 802.11ax.
Interface invariant: New control frames (RTS/CTS) and a new field (Duration). The interface widens — the cost of NAV is more interface complexity.

This is the conceptual move that motivates the entire 802.11 family: once you accept that overheard protocol frames can carry medium-state information, you’ve opened the door to scheduling. 802.11ax’s trigger frames are the same idea taken to its conclusion — the AP announces the entire medium schedule, and stations defer to that announcement.

RTS/CTS: Tradeoffs and Why It’s Optional

Why RTS/CTS is expensive: it’s sent at the PHY’s basic rate (so every legacy client can decode it), not at the high data rate.

For 802.11g: basic rate = 6 Mbps, peak data rate = 54 Mbps. Control frames run 9× slower than the data frame they protect.

Handshake cost added per frame (RTS + SIFS + CTS + SIFS, at 802.11g):

RTS (20 B @ 6 Mbps + PHY header) ≈ 52 µs
CTS (14 B @ 6 Mbps + PHY header) ≈ 44 µs
2 × SIFS = 32 µs
Total: ~130 µs added overhead before DATA can start

Compare to data airtime at 54 Mbps:

Frame size	Data airtime	Handshake / data ratio
50 B (TCP ACK)	~27 µs	~5× data
500 B	~94 µs	~1.4×
1500 B	~242 µs	~0.5×

For small frames, the handshake costs several times the payload. For large frames it’s a tax, not a killer.

Benefit: RTS/CTS shifts collisions to short control frames. A 20-byte RTS collision wastes ~52 µs; a 1500-byte data collision wastes ~242 µs + ACK timeout. Probability stays similar; cost-per-collision drops ~5×.

Limit: stations hidden from both TX and RX never hear the handshake. RTS/CTS extends the measurement radius from “what A hears” to “what A or B hears” — still not global.

Why 802.11 makes it optional: the cost-benefit flips with deployment density and frame size. Dense + large frames → enable. Sparse + small frames → disable. The protocol provides the mechanism; the deployer chooses the policy.

This slide makes the tradeoff structure concrete and quantifies it. Three things to land:

Collision shifting, not collision elimination. This is Karn’s deeper insight. If hidden terminals are inevitable (because measurement scope is bounded), the design move is not “prevent all collisions” — it is “make collisions cheap when they happen.” A 20-byte RTS collision wastes the handshake; a 1500-byte data collision wastes the entire frame plus ACK timeout. The cost ratio is roughly 10:1.
The handshake itself can collide. RTS frames from A and another sender can collide just like data frames would. But they are short, so the wasted airtime is small. RTS/CTS effectively replaces one expensive collision with several cheap ones — and the cheap ones converge faster under BEB because they are short.
Optionality as a design pattern. When a fix has variable cost-benefit across deployments, expose it as a tunable rather than enforce it. 802.11 does this in many places (RTS/CTS threshold, fragmentation threshold, beacon interval). This is a small example of a recurring principle: the protocol provides mechanism, the operator chooses policy.

Empirical default: most modern WiFi has RTS/CTS disabled by default for frames smaller than ~2300 bytes (the default RTSThreshold). It is enabled in dense enterprise deployments via AP configuration. Modern 802.11ax mostly bypasses the question by having the AP centrally schedule transmissions, but RTS/CTS still exists for legacy compatibility and edge cases.

Forward reference: in Part 2 we will see 802.11ax’s trigger frame, which is conceptually descended from CTS — a control frame that announces medium occupancy in advance and forces deferral. Karn’s idea, taken to its centralized conclusion.

DCF (1997): Protocol-Level Enhancements

→ Addressing Challenges 2 and 3. 802.11 DCF layers three additions on top of CSMA/CA.

The receiver wants to ACK. A new-attempt station also wants to transmit. Both are watching the medium. How do you guarantee the ACK always wins?

Shorter wait = higher priority. Introduce two inter-frame spaces:

Short Interframe Space (SIFS) — 16 µs: ACK’s wait
DCF Interframe Space (DIFS) — 34 µs: new-attempt wait (DIFS = SIFS + 2·slot)

→ Challenge 3 fix. The ACK’s shorter wait guarantees it preempts any new attempt.

Two stations collide. Both retry at random. What prevents them from colliding again?

Grow the random range on every collision: Binary Exponential Backoff (BEB).

After collision: \(CW \leftarrow \min(2 \cdot CW, CW_{\max})\)
After success: \(CW \leftarrow CW_{\min}\)
\(CW_{\min} = 31\), \(CW_{\max} = 1023\)

→ Challenge 2 fix. Same mechanism as Ethernet’s 1976 BEB.

What sets the slot duration that the random backoff decrements in?

Propagation delay + radio turnaround + CCA detect — enough for any station to sense another’s transmission by the next slot boundary.

802.11a/g: slot = 20 µs; 802.11b: 50 µs (slower PHY)
PHY-dependent; not a design parameter.

These are enhancements, not definitions. CSMA/CA worked before them; DCF packaged them together for efficiency.

This slide is the single Socratic moment that derives the three 802.11 DCF protocol-level enhancements from the challenges students identified on slide 5 (Four Challenges).

Structure the slide as three brief turn-to-neighbor moments, ~30 seconds each:

Q1 (priority via timing). Students should converge on “shorter wait = higher priority” once they realize the ACK and new-attempt station have no other way to coordinate. Any “priority bit” in a protocol flag would be invisible until the frame was decoded — too late. Only timing works. SIFS is chosen to be the radio’s physical turnaround time (~16 µs), the minimum possible wait. DIFS = SIFS + 2·slot ensures new attempts always wait longer, so the ACK always wins. This is NOT fundamental to CSMA/CA — it’s a 1997 DCF addition that makes the protocol more efficient.

Q2 (BEB). Students should reason: if we don’t change anything, they collide again. Need to spread the next retry over a larger range. How? Double the window. This is structurally identical to Ethernet’s BEB (1976), so 802.11 borrowed the idea. The key design choice: reset CW on success (not just grow forever), so the protocol recovers quickly after a contention burst. If students ask, MACAW (1994) actually used MILD backoff, not BEB — but BEB was simpler and worked, so DCF adopted BEB.

Q3 (slot time). Short answer: ≥ (propagation + radio turnaround + CCA detect). For 802.11a/g, this works out to 20 µs; for 802.11b, 50 µs. Students should recognize this as the same constraint as L5’s CSMA vulnerable window (τ). It’s the minimum time during which a station “commits” to a slot and other stations can still detect it.

Keep the reveal compact. The numerical constants (16, 34, 20, 50, 31, 1023) are not the teaching — the reasoning is. Students who know the reasoning will remember the structure; the numbers change with each PHY generation.

Transition to the next slide: “Now let’s see all these enhancements integrated into the DCF state machine — the book has a cleaner figure than we’ve been drawing.”

DCF: CSMA/CA + Enhancements, Integrated

802.11 DCF: Distributed Coordination Function — state machine (top) and timeline (bottom). Source: CS176C textbook, Figure V01.

What the figure shows:

State machine (top): IDLE → SENSE → DIFS_WAIT → BACKOFF → TRANSMIT → ACK_WAIT → SUCCESS or COLLISION → back to BACKOFF with doubled \(CW\)
Timeline (bottom): Station A transmits a frame (DIFS + backoff + TX + SIFS + ACK); Station B is backlogged too, but its backoff counter freezes during A’s transmission and resumes after A completes

This slide uses the book’s v01_dcf_protocol.svg — the canonical CS176C DCF figure. Prefer this over hand-drawn ASCII in every context where the book already has a figure.

What to say while showing the figure:

The green circles are “good” states — IDLE (nothing to send), SUCCESS (ACK received). The amber circles are the “active” path — TRANSMIT, ACK_WAIT. The red circle is COLLISION (ACK timeout).
Trace the happy path aloud: frame arrives → IDLE → SENSE → channel idle → DIFS_WAIT → BACKOFF → counter reaches zero → TRANSMIT → ACK_WAIT → ACK received → SUCCESS → reset CW → back to IDLE.
Trace the collision path: ACK_WAIT times out → COLLISION → CW doubles → new random backoff. Note the feedback loop is in the red arrow.
The timeline panel is critical pedagogy. Station B is transmitting (or trying to), but it correctly freezes during A’s frame. This is the fairness mechanism — B’s earlier wait is preserved across interruptions, so eventually B gets priority.
Every enhancement we derived on the prior slide appears here:
- SIFS < DIFS: in the timeline, the ACK fires after SIFS while new attempts would wait DIFS
- BEB: the red arrow labeled “CW = [0, 2^k − 1], k++”
- Slot time: the backoff counter decrements one slot at a time
- Counter freeze: Station B’s “Backoff frozen” box during A’s transmission

Do NOT re-derive the enhancements here — they were the prior slide. This slide shows the integration.

Transition to the mental-model slide: “We’ve walked through the full mechanism. Before we quantify its limits, let’s consolidate into an intuition that’s easy to remember.”

Mental Model: The Cocktail Party

You’ve just seen the whole protocol. Here’s the intuition to carry with you — DCF in six rules, one sentence each.

30 people in a room, one bartender (the AP), no moderator.

Listen. If anyone is talking, stay quiet. (carrier sense) . . .
When silence falls, don’t rush. Count to a polite pause (DIFS, ~34 µs). . . .
Roll a random die (0 to \(CW\)) and count that many short beats. If someone else starts talking mid-count, freeze — resume later. (random backoff + freeze) . . .
Talk when you hit zero — say your whole sentence. (transmit) . . .
Wait for the bartender’s “got it.” The bartender replies after a shorter pause (SIFS, ~16 µs). That shorter pause is the only reason their reply wins over anyone else trying to start a new sentence. . . .
If no “got it” comes back, assume you collided. Roll a bigger die next time — doubling on each failure. (BEB)

Every piece of this lecture — SIFS, DIFS, BEB, NAV, RTS/CTS, the 12 ms feedback loop, the four challenges — is a zoom-in on one of these six rules.

This is the consolidation slide. By now students have seen CSMA/CA principle, derived feedback-loop latency, worked through the four challenges, traced the hidden-terminal lineage (Tobagi-Kleinrock → Busy Tone → Karn → MACAW → NAV/RTS/CTS), derived SIFS/DIFS/slot/BEB, and looked at the integrated state machine figure. They have all the parts. This slide lets them mentally pack the parts into a single memorable frame.

Do not re-teach. Just walk through the six rules at conversational speed — ~30 seconds per rule, total ~3 minutes.

Key moment to land — rule 5 (SIFS). Students often miss why SIFS “helps.” Spell it out verbally: “After a data frame ends, two things want the medium: the receiver to send its ACK, and any other station to start a new transmission. If both waited the same interval, they’d collide. 802.11 gives the ACK a shorter wait (SIFS = 16 µs) than new attempts (DIFS = 34 µs). In the 18 µs gap, the ACK starts transmitting. Once it’s on air, normal carrier sensing causes the other station to defer. No priority bit, no reservation — just ‘wait less to win.’”

Key moment — rule 3 (freeze counter). Reinforce the fairness logic: “Freeze means your waiting time is preserved across interruptions. A station that’s been patiently waiting longer gets to go first when the medium clears.”

Hidden terminal is NOT in the six rules. Rule 1 (“listen”) assumes your listening tells you the truth about the medium at the receiver’s location. When it doesn’t (hidden terminal), RTS/CTS + NAV is an optional add-on — we covered it because it’s a classic and pedagogically rich story, but it lives outside the six-rule skeleton.

Close with: “When you see DCF in an exam or in the real world, reduce it back to these six rules. Every technical detail is an implementation choice in service of one of them.”

Bianchi (2000): The Throughput Ceiling Is Real

→ Quantifying Challenge 4 (density collapse). Even with all the DCF enhancements, a fundamental ceiling remains.

Setup: \(n\) stations, all backlogged, all using DCF. Each station transmits in any given slot with probability \(\tau\) (function of \(CW\)).

Collision probability per attempt: \(p = 1 - (1-\tau)^{n-1}\)

Saturated throughput (Bianchi’s analytical model):

\[S = \frac{\text{successful payload time}}{\text{idle slots} + \text{successful TX} + \text{collision TX}}\]

For 802.11b (\(CW_{\min}=31\), slot=20 µs, frame=1500B):

\(n = 5\): \(S \approx 0.78\) (near PHY rate)
\(n = 15\): \(S \approx 0.65\)
\(n = 30\): \(S \approx 0.50\)
\(n = 50\): \(S \approx 0.35\)
\(n = 100\): \(S \approx 0.15\)

Throughput
  ▲
  │ ● (n=5)
  │   ● (n=10)
  │     ● (n=15)
  │       ● (n=20)
  │         ● (n=30)
  │            ● (n=50)
  │                ● (n=100)
  │                     ● (n=200)
  └───────────────────────► n
          ~30 stations:
          inflection point

Two regimes:

Low \(n\): PHY rate dominates, MAC is fine
High \(n\): collisions grow faster than BEB can compensate

The ~30% ceiling is not a bug — it is the equilibrium of a slow control loop trying to manage many independent contenders with stale feedback.

Bianchi’s 2000 paper “Performance Analysis of the IEEE 802.11 Distributed Coordination Function” is the standard reference for this model. The analytical framework treats each station as a Markov chain whose state is the current backoff stage, computes the stationary transmission probability τ, and then derives saturated throughput as a function of n.

Walk through the intuition:

At low n (≤10), most slots are idle and most transmissions succeed. Throughput is limited by overhead (DIFS + backoff + SIFS + ACK), not collisions.
At moderate n (~15-30), collisions become non-trivial. BEB starts kicking in — the average CW grows — which spreads attempts but also wastes slots.
At high n (>30), the system spends most of its time in backoff or in collision recovery. The ratio of successful payload time to total time collapses.

Critical framing: this is structural, not implementational. You cannot fix it by tuning CW_min, choosing better backoff distributions, or improving carrier sensing. The control loop is too slow to respond to load changes that cycle 1000× faster than the loop period. The only fixes are (a) faster feedback (impossible in distributed CSMA), (b) global state (centralization), or (c) reduce contention by partitioning the channel (OFDMA).

This sets up the question that drives the rest of the lecture: WiFi survived 20 years on this protocol. How? And what finally broke it?

Framework Checkpoint: The Cascade Continues

L5 ended at CSMA/CD. Wireless couldn’t do CD, so the cascade bent:

Generation	Shared State	Throughput	Loop closes in	Key Failure
Pure ALOHA	Nothing	18.4%	—	Vulnerable window = \(2T\)
Slotted ALOHA	Slot timing	36.8%	—	Bistable instability
CSMA	Busy/idle (local)	80–90%	\(\tau\) (~5 µs)	Hidden terminal
CSMA/CD (wired)	Collision signal	~95%	51.2 µs	(Wired only)
CSMA/CA (principle)	ACK from receiver	N/A	~12 ms @ 1 Mbps	Backoff, ACK vuln., hidden, density
+ DCF (1997)	+ SIFS/DIFS + BEB + NAV	~30% at \(n{=}50\)	~12 ms / attempt	Density (irreducible)

The trade: wireless got a working protocol, but its feedback loop is frame-time-bounded (~250× slower than Ethernet’s propagation-bounded loop). DCF’s enhancements address 3 of 4 challenges — density is structural.

The question for next lecture: WiFi shipped DCF in 1997 and survived 20 years on it. Why? And what changed?

This is the narrow cascade view — “which shared-state addition at each step.” It extends L5’s framework table with two new rows. The point: the assumption cascade hasn’t stopped — it has bent. CSMA/CA is structurally weaker than CSMA/CD but possible under wireless physics, which CSMA/CD wasn’t.

Two threads to plant:

Why did WiFi ship a 30%-ceiling protocol? Because the deployment context for 1997-2010 was sparse — 5-10 devices per AP, where DCF works fine. The ceiling didn’t bite until smartphones. We’ll address this next lecture.
What’s the alternative? Two paths: faster feedback (impossible distributed) or centralization (the AP becomes a scheduler). 802.11ax took the second path. Cellular was always there. Convergence is the punchline — next lecture.

The next slide widens this table to all four invariants — showing which ones actually evolved over time.

Invariant Evolution: Which Questions Kept Re-Answering?

Which invariant’s answer kept changing across the cascade? Which stayed fixed?

Protocol	State	Time	Coordination	Interface
Pure ALOHA	None	Continuous TX	Distributed	Broadcast
Slotted ALOHA	+ Slot boundary	Slotted	Distributed	+ Slot timing
CSMA	+ Busy/idle (local)	Slotted	Distributed	+ Listen-before-talk
CSMA/CD (wired)	+ Collision signal	µs detection	Distributed	+ Abort + jam
CSMA/CA (principle)	+ ACK presence	Frame-TX bounded	Distributed	+ Link-layer ACK
+ DCF (1997)	+ CW history + NAV	Prescribed µs slots	Distributed	+ SIFS/DIFS/RTS/CTS

The pattern:

State kept growing at every step. Each generation added one more piece of shared or inferred knowledge.
Time got more structured (continuous → slotted → microsecond-prescribed) but stayed locally governed.
Coordination stayed fully distributed through the entire evolution. No one ever got a central authority.
Interface grew richer as more control frames appeared (ACK, RTS, CTS, Duration fields).

The ceiling is a coordination limit, not a state limit. Adding more state has diminishing returns — the next step requires changing who decides.

This is the comprehensive framework mapping slide. Walk students through the table column by column, making the point at the end.

State column: every row adds something. Pure ALOHA knew nothing. Slotted ALOHA added slot timing. CSMA added busy/idle. CSMA/CD added the collision signal. CSMA/CA added the ACK as a signal. DCF added CW history (the backoff state machine) and NAV (overheard reservations). State is the workhorse of medium access evolution — each generation solved its bottleneck by adding more shared or inferred knowledge.

Time column: moved from continuous (ALOHA) to slotted (Slotted ALOHA onward) to prescribed microsecond slots (DCF). But all of this is local timing — no station reads a global clock. The time structure got more rigid; the governance of time stayed distributed.

Coordination column: THIS is the column that didn’t change. Every protocol from 1970 to 1997 DCF is fully distributed. Each station decides independently based on local observation + overheard state. No central authority. This is the constraint that the ceiling comes from — adding more state helps, but only up to the point where distributed observation can inform distributed decisions. Beyond that, you need someone who sees the aggregate.

Interface column: grew richer as new control frames were added. Each new frame type (ACK, RTS, CTS, duration field) enabled a new kind of state to be communicated. Interface grew in step with State.

The punchline: the ceiling of CSMA/CA isn’t a state limit — you could add more state (timing advance, power reports, etc.) and gain some efficiency. But you can’t beat Bianchi’s ~30% under pure distributed contention no matter how much state you add. The ceiling is a coordination limit. Breaking it requires changing the coordination invariant — centralizing. That’s next lecture.

This slide is the intellectual bridge. It tells students: “you now understand why contention has a ceiling, and you understand that the answer is to change who decides. Come back next lecture to see how WiFi and cellular each made that move.”

Generative Exercise: The Coffee Shop at Peak Load

Scenario: One AP. 40 devices sharing it.

20 laptops streaming video (continuous large frames)
15 phones browsing (small bursts, lots of ACKs)
5 IoT sensors posting telemetry (tiny, infrequent)

Throughput feels bad to everyone. Why?

Turn to groups of 3 — 5 minutes:

1. Rank the four challenges

Of (a) backoff collisions, (b) ACK vulnerability, (c) hidden terminals, (d) density collapse — which dominate in this setting?

Defend each ranking.

2. Pick one. Design a fix.

What new mechanism would fix your top-ranked challenge? What new state does the mechanism need, and who has that state?

3. Can it be distributed?

Can your fix live within the existing DCF framework (fully distributed)? Or does it require a central authority?

What gives?

The insight most groups will reach: any fix that scales to this density needs someone who sees the aggregate. The only entity with that view is the AP. The protocol evolves toward centralization — which is next lecture’s story.

This is the closing generative exercise. Groups of 3, 5 minutes. Then cold-call 2-3 groups for their rankings and fixes.

Expected rankings (in rough order of severity for this scenario):

Density collapse (Challenge 4) — 40 stations is well past Bianchi’s inflection point. Pure DCF throughput collapses to ~15-20% here. This is the dominant failure.
Hidden terminal (Challenge 1) — in a coffee shop with pillars, walls, different tables, clients on opposite ends of the AP’s range are likely hidden from each other. Video streams and IoT devices in particular produce collisions at the AP that neither sender can diagnose.
ACK vulnerability (Challenge 3) — 15 phones each generating many small browsing transactions means many ACKs, each potentially colliding with other clients’ new attempts. DCF’s SIFS<DIFS helps but doesn’t eliminate the vulnerability when stations are hidden from each other.
Backoff collisions (Challenge 2) — BEB is working, but at high CW, it just means long waits rather than avoided collisions. The mechanism is doing what it can.

Expected fixes students will propose:

Schedule-based access (Challenge 4 fix): the AP announces who gets to transmit when. Requires state = all clients’ buffer status + channel quality at the AP. This is exactly 802.11ax OFDMA — next lecture.
Receiver-driven coordination (Challenge 1 fix): AP issues “next transmitter” commands based on buffer reports. Also requires central authority.
Per-client airtime budgets (Challenge 2+3 fix): AP manages share of airtime per client. Central.

Almost every realistic fix requires the AP to have global state. That’s the pedagogical payoff — students derive the centralization thesis themselves.

Close the lecture with: “You’ve just re-derived why WiFi had to change. Next lecture: how 802.11ax made that change, and what cellular was doing the whole time.”

This slide is the last of L6. Total: 16 slides (14 teaching + 1 invariant mapping + 1 generative).

Beyond CSMA/CA: Why WiFi Had to Change