TCP Window Sizing & BBR Congestion Control

TCP Window Sizing and Bottleneck Bandwidth and Round-trip propagation time (BBR) congestion control redefine network flow regulation. Unlike traditional loss-based algorithms (e.g., Cubic, Reno) that treat packet loss as the primary signal of network congestion—often inducing bufferbloat and underutilizing high-bandwidth, high-delay networks—BBR constructs an explicit model of the network path's maximum available bandwidth (RTprop and BtlBw). By continuously tracking the delivery rate and controlling pacing explicitly, BBR maximizes throughput while maintaining minimal queuing delay.

# Check currently available TCP congestion control algorithms
sysctl net.ipv4.tcp_available_congestion_control

# Enable the fq packet scheduler on the primary network interface (e.g., eth0)
sudo tc qdisc replace dev eth0 root fq

# Load the TCP BBR kernel module explicitly
sudo modprobe tcp_bbr

# Configure global default congestion control to bbr
sudo sysctl -w net.core.default_qdisc=fq
sudo sysctl -w net.ipv4.tcp_congestion_control=bbr

#include <sys/socket.h>
#include <netinet/tcp.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>

int configure_bbr_socket(int sockfd) {
    const char *algo = "bbr";
    socklen_t len = strlen(algo);
    
    // Apply TCP_CONGESTION socket option
    if (setsockopt(sockfd, IPPROTO_TCP, TCP_CONGESTION, algo, len) < 0) {
        perror("setsockopt(TCP_CONGESTION) failed; falling back to default");
        return -1;
    }
    
    // Enable TCP_NODELAY to disable Nagle's algorithm for interactive throughput
    int flag = 1;
    setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
    
    return 0;
}

# Query active TCP sockets filtering for BBR metrics (congestion window, pacing rate, rtt)
ss -i 'sport = :http or dport = :http'

# Sample output verification fields to observe:
# bbr:(bw:12480kbps,mrtt:12.5,pacing_gain:1.25,cwnd:45)

# Monitor live metrics using nstat or standard kernel tracepoints if needed

# Append parameters to system persistence configuration file
echo "net.core.default_qdisc=fq" | sudo tee -a /etc/sysctl.d/99-bbr.conf
echo "net.ipv4.tcp_congestion_control=bbr" | sudo tee -a /etc/sysctl.d/99-bbr.conf

# Apply system-wide without reboot
sudo sysctl --system

Mathematical Foundations of Window Sizing & BBR

Traditional TCP window sizing relies on the Additive Increase Multiplicative Decrease (AIMD) paradigm. The maximum window size is bounded by the Bandwidth-Delay Product (BDP): BDP = BtlBw * RTprop, where BtlBw is the bottleneck bandwidth and RTprop is the round-trip propagation time. Loss-based protocols inflate the congestion window (cwnd) until buffer overflow occurs, maximizing queue occupancy and inflating latency (bufferbloat). BBR decouples rate control from packet loss. It continuously tracks two fundamental variables: maximum delivery rate observed over a sliding window (BtlBw) and minimum round-trip time observed over a time window (RTprop). The pacing rate is calculated as: PacingRate = pacing_gain * BtlBw, and the control window is bounded by: cwnd = cwnd_gain * BDP, ensuring high throughput without inducing router queue build-up.

State Machine Transitions in BBR

BBR operates via a cyclical state machine designed to probe bandwidth and minimize latency without disruption. The states include: STARTUP (exponential growth phase to quickly fill the pipe, equivalent to slow start but aggressive pacing), DRAIN (lowers the pacing rate to drain queues accumulated during Startup), PROBE_BW (steady-state phase cycling through pacing gains [1.25, 0.75, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] to measure maximum throughput and share bandwidth fairly), and PROBE_RTT (briefly reduces cwnd to 4 segments every 10 seconds to force an accurate measurement of RTprop if it has not been updated recently).

Architectural Integration with Kernel Packet Schedulers

BBR cannot function in isolation at the transport layer; it requires integration with a packet scheduler at the data link boundary, specifically Fair Queueing (fq). While the TCP stack calculates when a packet can be sent and at what target pacing rate, the fq qdisc enforces this timing by delaying packet transmission from the kernel socket buffer to the network device driver. This eliminates bursty packet transmissions characteristic of traditional TCP stacks, replacing them with smooth, hardware-paced micro-bursts that align precisely with the path capacity.