TCP Congestion Control Explained: Reno, CUBIC, BBR v1 to v3, ECN and L4S for Cloud and Data-Center Networks (2026)
A single lost packet every few minutes is enough to keep a classic TCP flow on a 10 Gbps, 50 ms path at a small fraction of line rate. That is not a bug in your NIC or your cloud provider; it is arithmetic baked into how TCP congestion control reacts to loss. In 2026 the arithmetic matters more than ever: cross-region replication, AI dataset transfers and video egress all run over high bandwidth-delay paths, while user-facing traffic is judged on tail latency. Meanwhile the toolbox has changed. CUBIC is now a Standards Track RFC, BBRv3 is an IETF working-group draft, Linux negotiates Accurate ECN, and cable operators ship L4S to millions of homes.
This guide explains the control loop from first principles, works the numbers for real links, and shows when each algorithm wins or quietly hurts you.
What this covers: AIMD and slow start, Reno and CUBIC maths, BBR v1 to v3 state machines, ECN, DCTCP and L4S, Linux tuning and measurement, failure modes, and a decision table.
Context and Background
TCP congestion control exists because the Internet nearly stopped working. In October 1986 the link between Lawrence Berkeley Laboratory and UC Berkeley, sites about 400 yards apart, dropped from 32 kbps to 40 bps. Every host kept retransmitting into full queues, so the network carried mostly duplicates. Van Jacobson’s 1988 SIGCOMM paper, Congestion Avoidance and Control, fixed it with a handful of sender-side rules: conserve packets, start slowly, estimate RTT variance properly, back off exponentially on timeouts, and grow the window additively while shrinking it multiplicatively.
That last rule is AIMD, additive increase and multiplicative decrease. It survives today because it converges: when several AIMD flows share a bottleneck, each loss event shrinks the larger flows by more absolute bytes, so allocations drift towards fairness. The modern codification of the loss-based machinery is RFC 5681, which defines slow start, congestion avoidance, fast retransmit and fast recovery for standard TCP.
Thirty-eight years later, the incumbent TCP congestion control algorithms are easy to name. CUBIC, specified in RFC 9438 (August 2023, Standards Track, obsoleting RFC 8312), is the default in Linux, Windows and Apple stacks according to the RFC itself. Google’s BBR, first described by Cardwell et al. in ACM Queue in 2016 and merged into Linux 4.9, models the path instead of waiting for loss. Inside data centers, DCTCP (RFC 8257) uses ECN marks from switches to keep queues tiny. At the edge, L4S (RFCs 9330 to 9332) aims to bring DCTCP-like behaviour to the public Internet.
The same ideas also run in user space now. QUIC’s loss recovery and congestion control live in the application, not the kernel, which changes who gets to pick the algorithm; our QUIC and HTTP/3 deep dive on loss recovery and congestion control covers that transport in detail. This post stays focused on the TCP congestion control algorithms themselves and how they behave on cloud and data-center paths. If you work on RDMA fabrics, the lossless-Ethernet side of the story (PFC, DCQCN) is covered separately in our comparison of RoCE v2, InfiniBand and Ultra Ethernet congestion control.
The thesis of this article is simple. Every TCP congestion control algorithm is a guess about what a congestion signal means. Reno and CUBIC treat loss as the signal. BBR treats delivery rate and minimum RTT as the signal. DCTCP and L4S treat a fine-grained ECN mark as the signal. Choosing well means matching that guess to your network’s actual buffers and markings.
How TCP Congestion Control Works: The Control Loop
TCP congestion control is a sender-side feedback loop that limits how much unacknowledged data a connection keeps in flight. The sender holds a congestion window (cwnd) and often a pacing rate, observes ACKs, RTT, loss and ECN marks, and adjusts both so throughput approaches the bottleneck capacity without building a standing queue.

Figure 1: The TCP congestion control loop. The sender’s controller sets cwnd and pacing; the bottleneck queue either delivers, marks or drops; ACKs and ECN echoes feed the estimator that updates the model.
The figure shows three hosts of state. The sender’s controller decides how much to send and how fast. The bottleneck, which is the slowest link on the path, owns the only queue that matters at any instant. The receiver turns what happened at that queue into ACKs, SACK blocks and ECN echoes, and those flow back into an estimator that every algorithm implements differently.
The window, the pipe and the bandwidth-delay product
The amount of data a path can hold in flight is its bandwidth-delay product, or BDP. It is the bottleneck rate multiplied by the round-trip propagation delay. A sender with less than one BDP in flight leaves the link idle for part of every round trip; a sender with more than one BDP in flight must be parking the excess in a queue somewhere.
Here is the worked number for a common cloud case, a 10 Gbps path with 50 ms RTT, roughly a transcontinental hop:
- BDP = 10 × 10⁹ bit/s × 0.050 s = 5 × 10⁸ bits = 62.5 MB.
- With a 1,448-byte MSS (1,500-byte MTU minus IP and TCP headers with timestamps), that is 62.5 × 10⁶ / 1,448 ≈ 43,163 segments.
So cwnd has to reach about 43,000 segments, and the socket buffers on both ends must allow at least 62.5 MB, before a single flow can fill that pipe. Linux autotuning bounds those buffers with net.ipv4.tcp_rmem and net.ipv4.tcp_wmem; a default maximum of a few megabytes caps throughput long before congestion control gets a say. The BDP is the single most useful number in this article, and the same reasoning about queues and utilisation appears in our guide to queueing theory, Little’s Law and tail latency.
Slow start, congestion avoidance and recovery
A new connection does not know the BDP, so it probes. In slow start, cwnd grows by one segment per ACK, which doubles it every round trip. Linux starts at an initial window of 10 segments, so reaching 43,163 segments takes about log₂(4,316) ≈ 12 round trips, or roughly 600 ms on our 50 ms path, if nothing goes wrong.
Slow start ends when cwnd crosses the slow-start threshold (ssthresh) or a loss occurs. In congestion avoidance, Reno adds roughly one segment per RTT. On three duplicate ACKs, fast retransmit resends the missing segment, and fast recovery sets ssthresh to half the flight size and continues from there instead of collapsing to one segment. A retransmission timeout is the expensive case: cwnd falls to one segment and slow start begins again.
Doubling per RTT is aggressive by design. The danger is the last round: if the previous round exactly filled the pipe, the next round sends up to twice the BDP and can overflow a shallow buffer in a burst. Linux mitigates this with HyStart, which exits slow start early when it sees ACK trains stretch or RTT rise, and BBR replaces exponential window growth with a paced rate ramp.
Congestion signals: loss, delay and marks
Every TCP congestion control algorithm in this guide differs mainly in which signal it trusts. Loss is unambiguous on a wired path with a tail-drop queue, but it arrives late: by the time a drop occurs, the buffer is already full and every flow sharing it has suffered the full queuing delay. Loss is also noisy on wireless links and with policers, where drops have nothing to do with a full queue.
Delay is an earlier signal. A rising RTT means a queue is forming. But delay is easy to misread: ACK aggregation, delayed ACKs, Wi-Fi scheduling and virtualised NICs all add jitter that looks like queuing.
ECN, Explicit Congestion Notification, is the third option. A router or switch that would otherwise drop sets the Congestion Experienced (CE) codepoint in the IP header instead, the receiver echoes it, and the sender reacts without losing data. Classic ECN (RFC 3168) only says “at least one mark this round trip”, while DCTCP and L4S use the fraction of marked packets as a proportional signal. Which of these three signals your congestion controller believes determines nearly everything about how it behaves.
Why pacing changed the game
Window-based TCP releases data whenever ACKs arrive, so ACK compression on the reverse path turns into bursts on the forward path. Pacing spreads transmissions evenly across the RTT at a chosen rate. BBR depends on pacing because its whole model is a rate. QUIC’s RFC 9002 also tells senders to pace, suggesting a rate of N × cwnd / smoothed_rtt with N slightly above 1, for example 1.25.
In Linux, pacing is implemented either by the fq queueing discipline or, since the 4.13 kernel era, by TCP’s internal pacing timer when fq is absent. The fq qdisc remains the cleaner option on busy servers because it also gives per-flow fairness at the host egress.
TCP Congestion Control Algorithms: Reno, CUBIC, BBR, DCTCP and L4S
With the loop in place, each TCP congestion control algorithm becomes a specific answer to two questions: how fast do I grow, and what do I do when I see a congestion signal.
Reno and the loss-rate ceiling
Reno is AIMD(1, 0.5): add one segment per RTT, halve on loss. It is fair between identical flows and stable, but it scales badly. After a loss at cwnd = 43,163, Reno drops to about 21,581 segments and climbs back at one segment per 50 ms round trip. Recovery takes about 21,581 × 0.05 s ≈ 1,079 s, nearly 18 minutes, during which the link averages around 75% utilisation.
The Mathis model makes the ceiling explicit. Steady-state Reno throughput is approximately (MSS / RTT) × 1.22 / √p, where p is the loss probability. Rearranging for our 10 Gbps, 50 ms path with a 1,448-byte MSS (11,584 bits):
- √p = 1.22 × 11,584 / (0.05 × 10¹⁰) ≈ 2.83 × 10⁻⁵
- p ≈ 8.0 × 10⁻¹⁰
That is one loss per roughly 1.25 billion packets, a loss rate no loss-based TCP congestion control scheme can count on. No real WAN path delivers that, so a single Reno flow on a long fat pipe is effectively capped by background loss rather than capacity. This is the arithmetic behind this article’s first sentence, and it is why nobody runs Reno on such paths any more.
CUBIC: time-based growth for long fat networks
CUBIC keeps the loss signal but changes the growth curve. Instead of adding per ACK, it sets the window as a function of real time since the last congestion event:
W_cubic(t) = C × (t − K)³ + W_max
W_max is the window at the last reduction, C is a scaling constant that RFC 9438 says SHOULD be 0.4, and K is the time the curve takes to climb back to W_max. On loss, CUBIC multiplies cwnd by β_cubic = 0.7, a gentler cut than Reno’s 0.5. Solving for K gives K = ∛(W_max × (1 − β) / C).
For our 43,163-segment window: W_max × 0.3 = 12,949; divided by 0.4 that is 32,372; the cube root is about 31.9 seconds. CUBIC regains its old window in roughly 32 seconds instead of Reno’s 18 minutes. Because growth depends on elapsed time rather than ACK arrivals, two CUBIC flows with different RTTs grow at similar rates, which is fairer than Reno’s strong bias against long-RTT flows.
The cubic shape is the other clever part. Growth is fast when far below W_max, flattens into a plateau near W_max where the last loss occurred, and then accelerates again to probe for newly freed capacity. RFC 9438 also defines a Reno-friendly region: CUBIC computes what an AIMD flow would have reached (W_est) and uses the larger of the two, so on short-RTT, low-BDP paths it behaves no worse than Reno. Fast convergence lowers W_max further when a flow sees loss below its previous peak, ceding bandwidth to newcomers.
CUBIC’s weakness as a TCP congestion control design is the signal, not the curve. It still fills the bottleneck buffer until something drops. On a deep buffer that means persistent queuing delay, the condition known as bufferbloat. On a lossy wireless path it means backing off from random drops that have nothing to do with congestion.
BBR v1: modelling the path instead of waiting for loss
BBR, short for Bottleneck Bandwidth and Round-trip propagation time, flips the question. Rather than inferring capacity from loss, it continuously estimates two numbers: the maximum recent delivery rate (BtlBw) and the minimum recent RTT (RTprop). Their product is the BDP. BBR then paces at roughly BtlBw and caps inflight at a small multiple of BDP.
The insight from the 2016 ACM Queue paper is that the optimal operating point, Kleinrock’s point, sits where inflight equals BDP: maximum delivery rate, minimum RTT. Loss-based algorithms operate further right, at the point where the buffer overflows. BBR tries to sit on the knee of the curve.
Google’s own published results were striking. In the 2017 announcement that BBR came to Google Cloud, Google reported that BBR improved YouTube throughput by 4% on average globally and more than 14% in some countries, cut RTT by 33%, and powers TCP traffic from google.com. Its synthetic tests showed a 10 Gbps, 100 ms path with 1% loss where CUBIC achieved about 3.3 Mbps and BBR over 9,100 Mbps. Those are vendor numbers on specific setups, but the direction is consistent with the maths above.
BBR v1 had real problems, though. It largely ignored loss, so in shallow buffers it could sustain high retransmission rates. Its probing phase pushed inflight to 1.25 × BDP every eight round trips regardless of what else shared the queue. And it competed unpredictably with CUBIC, as the fairness section below explains.
BBR v2 and BBR v3: putting loss and ECN back in the model
BBR v2 added a loss and ECN response, bounding inflight below the level at which loss or marks were seen. BBR v3, released as open source in July 2023, fixed bandwidth-convergence bugs and retuned parameters; the BBR team’s announcement noted that “many conclusions about BBRv2 will no longer apply to BBRv3”.
The current specification is draft-ietf-ccwg-bbr-06, published 6 July 2026 by the IETF Congestion Control Working Group (CCWG) with intended status Experimental. It explicitly “specifies version 3 of the BBR algorithm, BBRv3”. The key constants it defines are worth knowing because they explain BBRv3’s behaviour:
| Parameter | BBRv3 value (draft-06) | What it does |
|---|---|---|
| Startup pacing gain | ≈ 2.77 (4 × ln 2) | Lets the sending rate double each round |
| Drain pacing gain | 0.5 | Empties the queue built in Startup |
| Default cwnd gain | 2 | Caps inflight at 2 × BDP in most phases |
| ProbeBW_UP pacing gain | 1.25 | Probes for more bandwidth |
| ProbeBW_DOWN pacing gain | 0.90 | Drains the queue created by probing |
| LossThresh | 2% per round trip | Loss rate that ends a bandwidth probe |
| Beta | 0.7 | Multiplicative decrease per round with loss |
| Headroom | 0.15 | Leaves room for other flows after loss |
| ProbeRTT | cwnd gain 0.5, ≥200 ms, every 5 s | Re-measures minimum RTT |
| min_rtt filter | 10 s | Window for the RTprop estimate |

Figure 2: BBRv3 state machine per draft-ietf-ccwg-bbr-06. ProbeBW cycles through DOWN, CRUISE, REFILL and UP; loss above 2% or ECN marks end a probe early; ProbeRTT runs when the min-RTT sample is stale.
The state machine reads top to bottom. Startup ramps quickly until the bandwidth estimate plateaus (three rounds without 25% growth) or loss is excessive. Drain then pulls inflight down to the estimated BDP. ProbeBW is the steady state, and it is where v3 differs most from v1: rather than a fixed eight-phase gain cycle, it spends most time CRUISEing at gain 1.0, periodically REFILLs the pipe for one round, probes UP at 1.25, and then goes DOWN at 0.90 to drain what probing added. Two inflight bounds, a long-term one and a short-term one, are tightened whenever loss or ECN shows the probe overshot.
ProbeRTT costs throughput by design. If inflight is halved for at least 200 ms every 5 seconds, the flow spends about 4% of wall-clock time at reduced inflight. On paths where RTT never truly drops, that is a recurring, visible sawtooth in throughput graphs.
On ECN, the draft is deliberately minimal: an implementation that claims ECN support “MUST treat any CE marks as congestion”. Google’s open-source Linux BBRv3 adds an ecn_low per-route feature for paths with DCTCP or L4S-style shallow marking, and its README warns not to use it where marks are RFC 3168-style.
Where BBRv3 actually ships
Here precision matters, because many blog posts get it wrong. Mainline Linux’s tcp_bbr module is still BBR v1. BBRv3 for Linux lives in the v3 branch of Google’s google/bbr repository, which the draft lists as production maturity and dual-licensed GPLv2/BSD, last updated November 2023. In September 2025 Neal Cardwell told the bbr-dev list that the team had no releases to announce and was focused on the IETF draft. QUIC implementations, notably Google’s QUICHE bbr2_sender, carry BBRv2/v3-family code in user space.
So if you run sysctl -w net.ipv4.tcp_congestion_control=bbr on a stock 2026 distribution kernel, you get v1. To run BBRv3 in TCP you must build a kernel from Google’s branch or use a distribution or vendor kernel that carries the patches. Google has presented BBRv3 as deployed on its public Internet traffic at IETF meetings, but the draft itself does not enumerate services, so treat specific service claims as reported.
DCTCP: proportional reaction inside the data center
DCTCP, specified as an Informational RFC 8257 in October 2017, was built for a single administrative domain with ECN-capable switches. Switches mark CE as soon as the instantaneous queue exceeds a small threshold K. The sender tracks the fraction of marked bytes per window and smooths it:
α ← α × (1 − g) + g × M
M is the fraction of bytes marked in the last window and g is a gain; the RFC leaves g to implementations, and Linux’s tcp_dctcp uses 1/16. On congestion, DCTCP sets cwnd ← cwnd × (1 − α / 2). If only a few packets were marked, α is small and the cut is tiny; if every packet was marked, α approaches 1 and DCTCP halves like Reno.
The result is a queue that hovers near K instead of filling. The RFC cites the original paper’s guidance of K > (RTT × C) / 7, with C in packets per second. As an illustration, a 100 Gbps link with 1,500-byte packets carries about 8.33 million packets per second; with a 20 µs fabric RTT, RTT × C ≈ 167 packets, so K should be above roughly 24 packets, about 36 KB. Compare that with a shallow-buffer switch holding a few megabytes shared across many ports.
The RFC is blunt about scope. DCTCP “MUST NOT be deployed over the public Internet without additional measures”, coexists poorly with conventional TCP in the same queue, and has no negotiation, so both ends and every hop must be configured. In practice, operators segregate DCTCP traffic into its own switch queue or use it only on east-west traffic.
ECN, Accurate ECN and L4S
Classic ECN (RFC 3168) uses two IP header bits for four codepoints: Not-ECT, ECT(0), ECT(1) and CE. TCP echoes a mark with the ECE flag until the sender acknowledges with CWR. That design yields at most one congestion signal per RTT, which is fine for Reno-style halving but useless for proportional controllers like DCTCP.
Accurate ECN fixes the feedback. RFC 9768, published April 2026 on the Standards Track and updating RFC 3168, repurposes the ECE, CWR and former NS bits as a three-bit ACE counter of CE-marked packets, with optional TCP options carrying byte counters for CE, ECT(0) and ECT(1). Linux merged AccECN negotiation in the 6.18 merge window according to LWN, and the kernel’s tcp_ecn sysctl now has values 3 to 5 for AccECN. The documented default remains 2: accept ECN on incoming connections but do not request it on outgoing ones.
L4S, Low Latency Low Loss Scalable throughput, builds on all of this to bring sub-millisecond queuing to the public Internet. RFC 9330 describes the architecture, RFC 9331 (Experimental) defines ECT(1) as the L4S identifier, and RFC 9332 (Experimental) specifies the DualQ Coupled AQM that lets L4S and classic traffic share a link without starving each other.

Figure 3: L4S DualQ Coupled AQM per RFC 9332. ECT(1) and CE packets enter the shallow L queue; classic packets enter a deeper queue; one base AQM couples the two marking probabilities so scalable and classic flows converge to similar rates.
The coupling is the clever part. A base PI controller watches the classic queue and computes p′. Classic packets are dropped or marked with probability p_C = (p′)², the square matching Reno and CUBIC’s 1/√p throughput law. L4S packets are marked with probability p_CL = k × p′, linear to match scalable controllers whose throughput goes as 1/p, with k = 2 recommended. Because both flows respond to the same underlying p′, they end up with roughly equal rates despite very different queue depths.
RFC 9332’s example DualPI2 tunes the classic queue around 15 ms and starts L4S marking at 800 µs with a 400 µs ramp. Deployment is real: in January 2025 Comcast began rolling out L4S-based low-latency DOCSIS in Atlanta, Chicago, Colorado Springs, Philadelphia, Rockville and San Francisco, citing FaceTime, GeForce NOW and Steam games as beneficiaries. Apple presented L4S results from its devices at IETF 123 in 2025.
Deeper Analysis: TCP Congestion Control Fairness, Linux Tuning and Measurement
Understanding each TCP congestion control algorithm in isolation is the easy half. Production problems come from interactions: algorithms sharing a queue, hosts with mis-sized buffers, and measurements that hide the real behaviour.
CUBIC vs BBR: who wins a shared bottleneck
The CUBIC vs BBR question has a counterintuitive answer: it depends mostly on buffer depth, not on which algorithm is “better”. Ware, Mukerjee, Seshan and Sherry’s IMC 2019 paper modelled the interaction. Their key finding was that BBR v1’s share when competing with loss-based flows does not depend on how many CUBIC flows there are. BBR’s inflight is capped at 2 × BDP based on its own estimates, and that cap, not its bandwidth estimate, sets its rate. In their simple model, one BBR flow can take up to half the link against any number of CUBIC flows, and the robust model predicted BBR’s throughput against CUBIC with a median error of 5%.
The buffer-depth dependence follows from the mechanisms. In a shallow buffer, CUBIC’s sawtooth repeatedly hits loss while BBR v1 keeps pacing near its estimate, so BBR dominates. In a very deep buffer, CUBIC fills the queue, inflates the RTT that BBR measures, and BBR’s 2 × BDP cap becomes the binding constraint; CUBIC can then take the larger share. BBRv3’s loss threshold and headroom are designed to back off sooner when it sees loss caused by others, which reduces but does not eliminate these effects.
Fairness also cuts across RTTs. With BBR, a longer-RTT flow computes a larger BDP and so is allowed more inflight, which can favour it in shared queues, the opposite of Reno’s bias. In practice, mixed fleets should be tested on their actual bottleneck rather than reasoned about from papers.
Configuring Linux
On Linux, TCP congestion control is a per-socket choice with a system default. Start by checking what is available and active:
# What is compiled in or loaded, and what is the default?
sysctl net.ipv4.tcp_available_congestion_control
sysctl net.ipv4.tcp_congestion_control
sysctl net.core.default_qdisc
# Load BBR (mainline module is BBR v1) and make it the default
sudo modprobe tcp_bbr
sudo sysctl -w net.core.default_qdisc=fq
sudo sysctl -w net.ipv4.tcp_congestion_control=bbr
# Persist across reboots
cat <<'EOF' | sudo tee /etc/sysctl.d/90-congestion.conf
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr
EOF
sudo sysctl --system
Note that default_qdisc applies only to interfaces whose root qdisc is created afterwards; on a running interface, replace it explicitly with tc qdisc replace dev eth0 root fq. On multi-queue NICs the default mq root attaches a child qdisc per queue, which is usually what you want.
Buffers must cover the BDP or no algorithm can fill the pipe. For the 62.5 MB example path, raise the maxima:
# min default max, in bytes; max sized for about 2 x BDP on a 10G 50ms path
sudo sysctl -w net.ipv4.tcp_rmem="4096 131072 134217728"
sudo sysctl -w net.ipv4.tcp_wmem="4096 16384 134217728"
sudo sysctl -w net.core.rmem_max=134217728
sudo sysctl -w net.core.wmem_max=134217728
# ECN: 1 = request and accept classic ECN; 3 = AccECN on kernels that support it
sudo sysctl -w net.ipv4.tcp_ecn=1
These values are a starting point, not a recommendation for every host. Large buffers on a server with thousands of connections multiply memory usage, so size maxima to the BDP of paths you actually serve.
Congestion control can also be set per route, which is useful when a host talks both to a data-center peer and to the Internet. The congctl route attribute pins an algorithm to a prefix:
# DCTCP only toward the in-fabric subnet, default elsewhere
sudo modprobe tcp_dctcp
sudo ip route replace 10.20.0.0/16 via 10.20.0.1 dev eth1 congctl dctcp
Applications can override the default per socket with setsockopt(fd, IPPROTO_TCP, TCP_CONGESTION, "bbr", 3), subject to net.ipv4.tcp_allowed_congestion_control for unprivileged processes.
Measuring what TCP congestion control is actually doing
ss exposes the kernel’s per-socket congestion state, which is far more useful than throughput alone:
# Show TCP internals for connections to port 5201 (iperf3)
ss -tin '( dport = :5201 or sport = :5201 )'
Typical output includes the algorithm name, cwnd, ssthresh, rtt (smoothed and variance), minrtt, pacing_rate, delivery_rate, retrans and, for BBR, a bbr:(bw:...,mrtt:...,pacing_gain:...,cwnd_gain:...) block. Three readings answer most questions. If cwnd × MSS is far below the BDP and retrans is zero, you are receiver-window or buffer limited. If rtt is many times minrtt, a standing queue exists. If retrans climbs steadily under BBR, the bottleneck buffer is shallow relative to BBR’s probing.
iperf3 drives controlled tests and lets you pick the algorithm per run:
# Server
iperf3 -s
# Client: 30 s test, 4 parallel streams, explicit congestion controller
iperf3 -c server.example -t 30 -P 4 -C cubic
iperf3 -c server.example -t 30 -P 4 -C bbr
# Measure latency under load at the same time from another shell
ping -i 0.2 server.example
Running ping concurrently is the cheapest bufferbloat test available. Idle RTT versus loaded RTT tells you how much queue your congestion controller builds. A path that idles at 40 ms and sits at 400 ms under CUBIC load has a large unmanaged buffer; that is exactly the situation in Google’s synthetic test, where a 1,000-packet buffer at 10 Mbps holds 1,000 × 1,500 × 8 / 10⁷ = 1.2 seconds of data and CUBIC’s median RTT reached 1,090 ms.
For sustained observability, export these counters. nstat reports system-wide TcpRetransSegs, TcpExtTCPLostRetransmit and ECN counters such as TcpExtTCPDeliveredCE, and eBPF tools can sample tcp_probe or tcp_retransmit_skb tracepoints per flow.
Cloud provider notes
Cloud networks shape what any host-side TCP congestion control algorithm can do. Google has stated publicly that BBR serves google.com traffic and GCP services such as Cloud Storage, Cloud Load Balancing and Cloud CDN; that is a provider-side choice that affects your clients’ downloads, not your VMs’ defaults. Your VM’s kernel default is whatever the image ships, which for mainstream Linux images is typically CUBIC; verify with sysctl rather than assuming.
Hypervisors and virtual NICs add their own effects. Many cloud networks enforce per-instance or per-flow bandwidth limits with token-bucket policers or shapers. A policer drops packets above the rate without queuing, which loss-based CUBIC reads as congestion and BBR may simply overrun until its loss bounds engage. If you see a flat throughput ceiling with periodic retransmission bursts, suspect a policer before blaming the algorithm. Provider documentation on per-flow limits changes often; check current values for your instance family rather than relying on blog figures.
Load balancers terminate TCP too. An L4 load balancer that proxies connections splits the path into two control loops with independent congestion controllers, which can help long-RTT clients but hides end-to-end behaviour. Pass-through designs such as XDP-based L4 balancers keep a single end-to-end loop; see our XDP and eBPF layer-4 load balancer guide for how Katran, Cilium and Maglev preserve flows, and our comparison of load-balancing algorithms and L4 vs L7 trade-offs for where proxies enter the picture.
Decision table: which algorithm for which network
| Network | Typical bottleneck | Recommended controller | Why | Watch for |
|---|---|---|---|---|
| Single-tenant DC fabric with ECN switches | Shallow switch buffers | DCTCP | Proportional ECN response keeps queues near K | Must isolate from non-DCTCP traffic |
| Mixed DC, no ECN tuning | Shared shallow buffers | CUBIC, or BBR after testing | CUBIC is safe default; BBR may cause retransmits | Incast, retransmit storms |
| Cross-region WAN, 10 Gbps+, 30–150 ms | Provider WAN, policers | BBR with fq pacing |
Insensitive to random loss, fills high-BDP pipes | Fairness to CUBIC peers, policer drops |
| Internet egress to consumer clients | Last-mile access buffers | BBR on servers; CUBIC acceptable | Lower queuing delay, better on lossy last miles | Mobile and Wi-Fi RTT noise |
| Path with L4S DualQ AQM | Access network AQM | L4S scalable CC, e.g. Prague or BBRv3 ecn_low |
Sub-ms queuing with full throughput | Classic ECN bottlenecks misread as L4S |
| Constrained IoT and LPWAN | Radio duty cycle | Transport-specific; often not TCP | Small windows, high loss, long sleep | Timeouts dominate, not cwnd |
| Bulk background transfer | Any shared link | LEDBAT-style scavenger, where available | Yields to foreground traffic | Starvation if path is always busy |
The last two rows are deliberately less prescriptive. Constrained IoT links often use CoAP over UDP with its own simple congestion rules; our article on securing CoAP for constrained IoT with DTLS 1.3, OSCORE and EDHOC covers that stack, where retransmission timers matter far more than window growth.
Trade-offs, Gotchas, and What Goes Wrong
TCP congestion control failures are rarely dramatic. They show up as a throughput plateau, a latency tail or a retransmission counter that nobody graphs.

Figure 4: A practical selection flow. Start from the administrative domain and the bottleneck’s marking behaviour, then pick DCTCP, an L4S controller, BBR or CUBIC, and always close the loop with measurement.
The flow encodes the most common mistakes in reverse. Each decision node is a question operators skip.
Switching to BBR fixes bufferbloat for you, not for everyone. BBR v1 builds far smaller queues than CUBIC on its own, but its 1.25 × BDP probes and its loss insensitivity can raise retransmissions for every flow sharing a shallow buffer. Rolling BBR v1 out across a fleet that shares top-of-rack buffers can shift pain from your service to a neighbour’s.
Running DCTCP outside its domain. Enabling tcp_dctcp on hosts that also reach the Internet, without per-route congctl, means DCTCP meets classic ECN or no ECN at all. Without proportional marking it degrades towards Reno-like behaviour on loss and can be unfair in queues shared with CUBIC.
Classic ECN bottlenecks seen by L4S senders. An L4S sender that meets a single-queue RFC 3168 AQM marking ECT(1) packets can push classic flows aside, because it expects frequent marks and reacts gently to each. RFC 9330 and the L4S operational guidance discuss detection heuristics; until those are universal, enabling L4S behaviour should follow evidence that the bottleneck is DualQ.
Middleboxes and ECN bleaching. Some firewalls and older routers clear or mishandle ECN bits, or drop SYNs with ECN flags. Linux falls back gracefully, but fallback means you silently lose the signal. Check TcpExtTCPDeliveredCE and ECN negotiation counters before assuming ECN is in effect.
Undersized socket buffers masquerade as congestion control problems. If tcp_rmem or tcp_wmem maxima are below the BDP, every algorithm plateaus at the same throughput. Engineers then swap algorithms, see no change, and conclude TCP congestion control is irrelevant.
Policers and shapers. Token-bucket policers drop bursts above a configured rate. CUBIC repeatedly halves; BBR may keep sending into the policer. BBRv2 and v3 detect high loss and bound inflight, which helps, but explicit pacing below the policed rate is the robust fix when you know the limit.
Delay-signal noise on virtualised and wireless paths. ACK aggregation from GRO, delayed ACKs and Wi-Fi batching all distort RTT and delivery-rate samples. BBR’s max filter on bandwidth and min filter on RTT are tolerant, but extreme aggregation can inflate bandwidth estimates and cause bursts.
ProbeRTT and periodic dips. Latency-sensitive streams on BBR can see a short throughput dip every few seconds as ProbeRTT halves inflight. That is expected behaviour, but it surprises teams who graph per-second throughput.
Incast in the data center. Many senders responding simultaneously to one receiver overflow a shallow port buffer within microseconds, faster than any end-to-end loop can react. DCTCP reduces the frequency; application-level request pacing and receiver-driven designs are often still required.
Version confusion. Teams quote BBRv3 results and then deploy the mainline module, which is v1. Write down which kernel tree and commit you run, and test that exact build.
Practical Recommendations
Treat TCP congestion control as a configuration of the network, not of the host. Start by identifying your bottleneck for each traffic class and asking what signal it produces: drops from a deep FIFO, drops from a policer, classic ECN marks, or DCTCP and L4S-style shallow marks. That answer narrows the choice more than any benchmark.
For most cloud fleets, the pragmatic baseline in 2026 is CUBIC with fq or fq_codel at the host, ECN enabled, and socket buffers sized to the largest BDP you serve. Move Internet-facing and cross-region bulk senders to BBR with fq pacing after an A/B test that records retransmissions and loaded RTT, not only throughput. Reserve DCTCP for fabrics where you control every switch’s ECN thresholds and can isolate its queue. Treat BBRv3 and L4S as targeted deployments: build or obtain the kernel deliberately, and enable L4S behaviour only where the path has a DualQ AQM.
Measure TCP congestion control behaviour continuously. Per-flow ss snapshots, nstat counters and loaded-RTT probes are cheap, and they catch the failure modes above long before users do. Repeat tests after kernel upgrades, because defaults such as ECN negotiation and pacing behaviour do change between releases.
A short checklist:
- [ ] Compute BDP for each major path and size
tcp_rmem/tcp_wmemmaxima to cover it. - [ ] Confirm the active algorithm, qdisc and kernel version on every host image.
- [ ] Enable
fq(orfq_codel) and ECN; verify marks withnstat. - [ ] A/B test BBR against CUBIC with throughput,
retransand loaded RTT. - [ ] Pin DCTCP per route only toward ECN-tuned fabrics.
- [ ] Record whether you run BBR v1 (mainline) or BBRv3 (Google branch).
- [ ] Graph retransmissions and RTT inflation, not just Gbps.
Frequently Asked Questions
What is the default TCP congestion control algorithm in Linux?
CUBIC has been the Linux default since kernel 2.6.19, and RFC 9438 notes it is also the default in Windows and Apple stacks. The kernel’s tcp_congestion_control default is set at build time, so a distribution can choose differently, but mainstream images ship CUBIC. Check with sysctl net.ipv4.tcp_congestion_control and list loaded options with tcp_available_congestion_control. Reno is always compiled in as a fallback. You can change the system default with sysctl, override it per route with ip route ... congctl, or override it per socket with the TCP_CONGESTION socket option.
Is BBR better than CUBIC?
Neither is universally better; the answer depends on buffers and loss. BBR usually wins on long, high-BDP paths with random loss, and it keeps queues smaller, which Google’s YouTube data reflected as 4% higher throughput and 33% lower RTT. CUBIC is more predictable in shared shallow buffers where BBR v1’s probing raises retransmissions. Fairness between the two depends heavily on buffer depth, as the IMC 2019 modelling work showed. Test both on your real bottleneck, measuring throughput, retransmissions and latency under load, before changing a fleet default.
Is BBRv3 in the mainline Linux kernel?
Not as of November 2026. Mainline Linux’s tcp_bbr module implements BBR v1, merged in kernel 4.9. BBRv3 for Linux TCP is published in the v3 branch of Google’s google/bbr repository, which the IETF draft lists as production maturity. In September 2025 the BBR team said it had no new releases to announce and was focusing on the CCWG draft, now draft-ietf-ccwg-bbr-06 with intended Experimental status. To run BBRv3 over TCP you need a kernel built with those patches; QUIC stacks can ship it in user space.
What is the difference between ECN and L4S?
Classic ECN, defined in RFC 3168, lets a router mark packets with Congestion Experienced instead of dropping them, and the sender reacts as if a loss happened, roughly once per round trip. L4S, defined in RFCs 9330 to 9332, uses the ECT(1) codepoint to identify scalable senders that expect frequent, shallow marks and respond proportionally. A DualQ Coupled AQM keeps L4S packets in a separate, very shallow queue, so they see sub-millisecond queuing, while coupling marking probabilities keeps classic and L4S flows roughly fair.
When should I use DCTCP?
Use DCTCP only inside a single administrative domain where you control every switch’s ECN marking threshold and every host’s configuration. RFC 8257 says it must not be deployed over the public Internet without additional measures and that it coexists poorly with conventional TCP in the same queue. The typical pattern is east-west data-center traffic, with switches marking above a small queue threshold and a separate traffic class for DCTCP. On Linux, enable it per route toward fabric subnets with congctl dctcp instead of changing the system-wide default.
How do I calculate the right TCP buffer size?
Multiply bottleneck bandwidth by round-trip time to get the bandwidth-delay product, then size the maximum socket buffer to at least that, often around twice it for headroom. A 10 Gbps path with 50 ms RTT has a BDP of 62.5 MB, so the defaults of a few megabytes would cap one flow far below line rate regardless of congestion control. Raise the third value of net.ipv4.tcp_rmem and tcp_wmem plus net.core.rmem_max and wmem_max. Remember that memory scales with concurrent connections.
Further Reading
- QUIC and HTTP/3 protocol deep dive: handshake, streams, loss recovery and congestion control — how the same algorithms run in user space over UDP.
- XDP and eBPF layer-4 load balancing with Katran, Cilium and Maglev — keeping end-to-end TCP loops intact through the load balancer.
- Securing CoAP for constrained IoT: DTLS 1.3, OSCORE and EDHOC compared — the constrained-network transport stack where TCP windows matter less than timers.
- RoCE v2 vs InfiniBand vs Ultra Ethernet congestion control for AI clusters — the lossless-fabric counterpart to DCTCP.
- RFC 9438: CUBIC for Fast and Long-Distance Networks — the Standards Track CUBIC specification.
- RFC 9332: Dual-Queue Coupled AQM for L4S — the AQM that makes L4S and classic traffic coexist.
By Riju — about
