3.1.1 The Sliding Window and Flow Control

TCP Flow Control uses the Sliding Window Protocol.

Study Deep: The AIMD Principle

TCP uses Additive Increase / Multiplicative Decrease:

• Increase: $CWND = CWND + 1$ every RTT (Linear).
• Decrease: $CWND = CWND / 2$ on loss (Exponential).
• Why?: This is mathematically proven to be Fair and Stable. If two users compete, the one using more bandwidth gets a larger "cut" during congestion, eventually leading both to an equal share of the link.

• The Problem: A fast sender (10Gbps) talks to a slow receiver (10Mbps).
• The Solution: The receiver advertises a "Window" ($RWND$).
• Math: $TargetWindow = min(CWND, RWND)$.

Pseudocode: Zero Window Persist Timer

void handle_zero_window(TCP_State *s) {
    if (s->advertised_window == 0) {
        s->persist_timer = RTO;
        while (s->advertised_window == 0) {
            wait_for(s->persist_timer);
            send_one_byte_probe(s);
            s->persist_timer = min(MAX_PERSIST, s->persist_timer * 2);
        }
    }
}

3.1.2 TCP Congestion Control Algorithms (SS/CA)

• Slow Start: $CWND = CWND + 1$ (Exponential).
• Congestion Avoidance: $CWND = CWND + 1/CWND$ (Linear).

Algorithmic Logic: Congestion State Machine

void on_ack_received(TCP_State *s, int ack_num) {
    if (s->cwnd < s->ssthresh) {
        // Slow Start Phase
        s->cwnd += 1; 
    } else {
        // Congestion Avoidance Phase
        s->cwnd += (1.0 / s->cwnd);
    }
}

void on_loss_detected(TCP_State *s, Event e) {
    if (e == TIMEOUT) {
        s->ssthresh = s->cwnd / 2;
        s->cwnd = 1;
    } else if (e == THREE_DUP_ACKS) {
        s->ssthresh = s->cwnd / 2;
        s->cwnd = s->ssthresh + 3; // Fast Recovery
    }
}

3.1.3 Advanced Extensions (SACK/FACK)

Selective Acknowledgments allow the receiver to report non-contiguous blocks.

• SACK Block Format: [Left Edge (32 bit), Right Edge (32 bit)].
• FACK Logic: Tracks $SND.FACK$ (the highest seq SACKed).

SACK Processing Pseudocode:

void process_sack_blocks(TCP_State *s, SackBlock blocks[], int num_blocks) {
    for (int i = 0; i < num_blocks; i++) {
        mark_as_received(s->scoreboard, blocks[i].left, blocks[i].right);
        if (blocks[i].right > s->fack_val) {
            s->fack_val = blocks[i].right;
        }
    }
    s->packets_in_flight = s->max_sent - s->last_ack - total_sacked(s->scoreboard);
}

3.1.4 Jain's Fairness Index

AIMD (Additive Increase Multiplicative Decrease) is mathematically proven to converge to fair sharing. $$J(x_1...x_n) = rac{(sum x_i)^2}{n sum x_i^2}$$