Skip to content
TheChatArchiveThe Chat Archive
ClaudeClaude Haiku 4.5· anthropicHugging Face Frontier Reasoning Traces

Explain TCP Tahoe versus Reno congestion control. How does Reno use fast recovery to…

  1. User

    Explain TCP Tahoe versus Reno congestion control. How does Reno use fast recovery to avoid slow start after triple duplicate ACK? Contrast additive increase versus multiplicative decrease.

  2. Claude Assistant

    This is a great question about TCP congestion control algorithms. Let me break down TCP Tahoe vs Reno comprehensively.

    TCP Tahoe

    TCP Tahoe is the original congestion control algorithm with these key characteristics:

    1. Slow Start Phase: Starts with congestion window (cwnd) = 1 and exponentially increases by doubling it for each ACK received (or increasing by 1 MSS per RTT effectively)
    2. Congestion Avoidance Phase: When cwnd reaches a threshold (ssthresh), it switches to linear increase
    3. Loss Detection: Uses two methods:
      • Timeout (RTO expiration)
      • Triple Duplicate ACK (3 duplicate ACKs)
    4. Reaction to Loss: Both timeout and 3 duplicate ACKs trigger:
      • cwnd reset to 1 MSS
      • ssthresh = max(cwnd/2, 2) MSS
      • Return to Slow Start phase

    The problem with Tahoe: Every loss event triggers slow start, which can be very inefficient if the loss is minor and the connection can recover faster.

    TCP Reno

    TCP Reno improves on Tahoe by distinguishing between timeout and 3 duplicate ACK losses:

    1. Timeout (Packet Loss Detected via RTO):

      • cwnd → 1 MSS
      • ssthresh = max(cwnd/2, 2) MSS
      • Enter Slow Start
      • (Same as Tahoe)
    2. Triple Duplicate ACK (Out-of-Order Indication):

      • Instead of going back to Slow Start, Reno introduces Fast Retransmit and Fast Recovery

    Fast Retransmit and Fast Recovery

    Fast Retransmit:

    • On receiving 3 duplicate ACKs, immediately retransmit the lost segment without waiting for timeout

    • This avoids the delay of waiting for an RTO expiration

    Fast Recovery:

    • When 3 duplicate ACKs detected:
      • ssthresh = cwnd / 2
      • cwnd = ssthresh + 3 MSS (the +3 accounts for the 3 duplicate ACKs that triggered recovery)
      • Enter Fast Recovery phase instead of reverting to Slow Start
    • During Fast Recovery, each additional duplicate ACK increments cwnd by 1 MSS, allowing continued transmission
    • When a new ACK arrives for the retransmitted packet, cwnd deflates to ssthresh and transitions to Congestion Avoidance
    • If a timeout occurs during recovery, fall back to Slow Start like Tahoe

    The critical difference: Fast Recovery maintains a higher cwnd while retransmitting, then resumes gradual increase rather than restarting from scratch. This prevents the severe throughput collapse that Tahoe experiences.

    Additive Increase vs Multiplicative Decrease

    The core tension in congestion control lies in how aggressively to probe for bandwidth versus how quickly to back off:

    Additive Increase (AI): During Congestion Avoidance, cwnd grows by 1 MSS per RTT (implemented as cwnd += MSS/cwnd per ACK), creating a linear ramp-up to gently test available capacity.

    Multiplicative Decrease (MD): Upon detecting loss, cwnd halves immediately, providing an aggressive pullback to prevent network saturation.

    This combination is known as AIMD -

    the foundation enabling multiple flows to converge toward fair bandwidth sharing while efficiently utilizing the network and maintaining stability. A comparison reveals how Tahoe and Reno diverge: Tahoe always returns to Slow Start after any loss, resetting cwnd to 1, while Reno only does this for timeout-detected losses—using Fast Recovery for duplicate ACKs instead. This means Reno maintains higher throughput when losses are sparse, whereas Tahoe suffers dramatic drops even from isolated packet losses. The visual difference is stark: Tahoe's cwnd trajectory shows a cliff-like drop from 32 back to 1, while Reno's path dips to 16 (half the previous value) and recovers linearly.

    The distinction between timeout and duplicate ACK detection is crucial—duplicate ACKs signal isolated loss in an otherwise functioning network, so Reno responds conservatively but continues forward. Timeouts indicate severe congestion or reordering, warranting the aggressive reset. This proportional response to loss severity is what makes Reno more efficient in practice.

    TCP Tahoe vs Reno Congestion Control

    Core Algorithms at a Glance

    AspectTahoeReno
    Loss via TimeoutSlow Start (cwnd=1)Slow Start (cwnd=1)
    Loss via 3-DupACKSlow Start (cwnd=1) ❌Fast Recovery (cwnd=ssthresh+3) ✓
    Key InnovationFirst TCP CC algorithmDistinguishes loss types
    EfficiencyLower (always resets)Higher (proportional response)

    Tahoe: The Original

    Slow Start Phase:
    cwnd: 1 → 2 → 4 → 8 → 16 → 32 → ...
          (exponential growth per RTT)
    
    Congestion Avoidance (after ssthresh):
    cwnd: increases by 1 per RTT (linear)
    
    ANY LOSS DETECTED:
      ├─ Timeout: cwnd = 1, enter Slow Start
      └─ 3-DupACK: cwnd = 1, enter Slow Start ← INEFFICIENT!
    

    Problem: Both loss signals trigger an aggressive reset, causing unnecessary throughput collapse for minor packet losses.


    Reno: Fast Recovery to the Rescue

    Key Insight: Distinguish Loss Severity

    TIMEOUT (severe congestion):
      cwnd = 1 MSS
      ssthresh = cwnd/2
      → Slow Start (conservative)
    
    3-DUPLICATE ACK (mild congestion):
      ssthresh = cwnd/2
      cwnd = ssthresh + 3 MSS  ← KEY: Don't reset!
      → Fast Recovery (aggressive)
    

    Fast Retransmit & Recovery in Action

    Step 1: DETECT LOSS
      Receive 3rd duplicate ACK
      → Immediately retransmit (don't wait for timeout)
    
    Step 2: FAST RECOVERY PHASE
      ssthresh = current_cwnd / 2      (e.g., 32/2 = 16)
      cwnd = ssthresh + 3              (e.g., 16+3 = 19)
      
      For each additional DupACK:
        cwnd++                          (e.g., 19→20→21...)
    
    Step 3: RECOVERY COMPLETE
      New ACK arrives for retransmitted packet:
        cwnd = ssthresh                 (deflate to 16)
        Enter Congestion Avoidance (linear growth)
        
    Step 4 (if timeout occurs):
      Abort recovery → fallback to Slow Start
    

    Concrete Example

    Tahoe (Loss at cwnd=32):

    send: [1][2][3]...[32]          cwnd grows to 32
          [X]                        packet 2 lost
    recv: ACK1 ACK1 ACK1             3 duplicate ACKs → TIMEOUT
    cwnd = 1                          RESET: back to slow start
    send: [1][2]                      ← Dramatic throughput drop!
    

    Reno (Loss at cwnd=32):

    send: [1][2][3]...[32]          cwnd grows to 32
          [X]                        packet 2 lost
    recv: ACK1 ACK1 ACK1             3 duplicate ACKs → FAST RETRANSMIT
    send:           [2]              retransmit immediately
    cwnd = 16 + 3 = 19               ← Stay productive!
    send: [33][34]...                continue sending at cwnd=19
          +3 MSS growth in recovery
    recv: ACK up to 33                exit fast recovery
    cwnd = 16                         smooth transition to congestion avoidance
    

    Additive Increase vs Multiplicative Decrease (AIMD)

    These are the fairness and stability principles underlying both algorithms:

    Additive Increase (AI)

    During Congestion Avoidance:

    cwnd += 1 MSS per RTT
    
    Implementation (per ACK):
      cwnd += MSS² / cwnd
    
    Visual:
      cwnd:
       ▲
       │        /
       │      /
       │    /         ← Linear (gentle probing)
       │  /
       └─────────────→ time
    

    Purpose: Gradual bandwidth exploration

    Multiplicative Decrease (MD)

    On Loss Detection:

    cwnd *= 0.5    (divide by 2)
    
    Visual:
      cwnd:
       ▲     ╲
       │      ╲╲
       │        ╲╲      ← Exponential drop (aggressive)
       │          ╲
       │           
       └─────────────→ time
    

    Purpose: Prevent congestion collapse

    Why This Asymmetry?

    ✓ Multiple flows converge to fairness:
      - AI ensures all flows increase together (fair)
      - MD ensures all flows back off equally (stable)
      
    ✓ Efficiency:
      - AI slowly fills available capacity
      - MD quickly responds to congestion signals
      
    ✓ Stability Guarantee:
      - The product of 2 flows' behavior remains bounded
      - Classic AIMD mathematics ensures stability
    

    AIMD Convergence Illustration

    Flow A    Flow B    Behavior
    ├─ 40% ──── 60%     Unequal (after initial loss)
    ├─ 50% ──── 50%     AI closes the gap
    ├─ 60% ──── 40%     More loss → MD
    ├─ 55% ──── 45%     AI regains balance
    └─ 50% ──── 50%     CONVERGES to fairness
    

    Why Reno Wins Over Tahoe

    ScenarioTahoe BehaviorReno Behavior
    Single packet drop (3-DupACK)cwnd 32→1 (96% loss) ❌cwnd 32→19 (41% loss) ✓
    Multiple packets dropRecover from Slow StartEventually falls back to Slow Start
    High-bandwidth networksPoor utilization ❌Better recovery ✓
    Bursty lossInefficient ❌Proportional response ✓

    Modern Context

    Reno Limitations: Only handles single-packet loss well; struggles with multiple losses (multiple fast recovery cycles).

    Modern Extensions (addressing Reno's gaps):

    • TCP NewReno: Better multiple loss handling
    • CUBIC: Used by Linux, improved for high-bandwidth networks
    • BBR: Proprietary (Google), model-based approach

    But Reno's AI/MD principles remain fundamental to TCP fairness and stability across the internet.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.