Changing a VPS from CUBIC to BBR3 is easy; proving it made anything faster is not. Most published comparisons are contaminated by a warm page cache, a single long-lived transfer, or a test path where the receiver, not the sender, is the bottleneck. This procedure isolates the congestion control algorithm so the numbers you collect reflect it and nothing else.
Prerequisites: kernel and module check
BBR3 ships in mainline Linux from 6.12 onward as a separate module from BBRv1. Verify what you actually have with sysctl net.ipv4.tcp_available_congestion_control and confirm the running algorithm via sysctl net.ipv4.tcp_congestion_control. A host kernel reporting only cubic, reno, and bbr is a v1 kernel regardless of what the control panel claims.
Check the module name with modinfo tcp_bbr. Some distributions package BBRv1 only, so tcp_bbr exists while BBR3 does not. If your provider’s kernel is too old, the options are a custom kernel on a KVM guest or a different host — container-based plans cannot upgrade the kernel at all. Record the exact kernel string from uname -r, because two providers on the same distro image can ship very different kernels.
Building a clean test path
Use two hosts with a known path between them, ideally the VPS and a second instance in the same region, so the internet does not dominate results. Disable segmentation offloads on the test NIC with ethtool -K eth0 tso off gso off gro off when you want packet-level accuracy, and record whether they were on or off, because they change measured throughput by 10% to 20%.
Set the receive window and queue sizes explicitly with sysctl -w net.core.rmem_max=16777216 net.core.wmem_max=16777216 net.ipv4.tcp_rmem="4096 131072 16777216" net.ipv4.tcp_wmem="4096 65536 16777216" on both ends. Mismatched buffers make CUBIC look better than it is, because CUBIC depends more heavily on a large receive window to fill the pipe.
Injecting realistic RTT and loss
Loopback testing proves nothing. Attach netem to a virtual interface to create controlled conditions: tc qdisc add dev eth0 root netem delay 40ms 5ms loss 0.1%. That approximates a cross-country path with mild loss, which is where the two algorithms diverge most. Test at 5 ms, 40 ms, and 120 ms RTT.
Do not add a limit to the netem queue when measuring throughput; a small queue will drop packets and both algorithms will converge on similar results. To test bufferbloat separately, add limit 1000 and record the RTT of a concurrent ping during the transfer. That is the number that matters for interactive traffic. BBR3 is designed to keep that figure bounded, while CUBIC will let the queue grow until loss occurs.
Running iperf3 correctly
Start the receiver with iperf3 -s -p 5201 and the sender with iperf3 -c RECEIVER -t 60 -P 4 -O 5. The -O 5 flag skips the first five seconds, which are dominated by slow start and by BBR’s initial bandwidth probing. Without it, short runs favour CUBIC’s faster ramp.
Run each algorithm for at least 60 seconds, three times, alternating order so thermal or host noise does not favour whichever ran first. Record the last 40 seconds of each report. Throughput in the first ten seconds is not the metric — steady-state goodput and retransmit count are. Repeat the whole sequence with a single stream (-P 1) as well.
Reading retransmits and queuing
Capture ss -tin during the transfer and note retransmits, cwnd, and rtt. BBR3 should show near-zero retransmits on a path with 0.1% loss, with cwnd driven by measured delivery rate rather than loss events. CUBIC will collapse cwnd on every loss and take several RTTs to recover, visible as a sawtooth in throughput. Save the ss output to a file every five seconds so you can compare the two runs afterwards.
On a lossy or buffer-bloated path the difference can be twofold or more. On a clean 5 ms path inside one data center, expect the difference to be within noise, often under 3%. If your results show a large gap on a clean path, suspect an error in setup rather than a genuine algorithm advantage.
Common ways the measurement lies
- Testing to a public speedtest endpoint that is rate limited or has its own congestion control.
- Leaving a disk benchmark or backup running on either host during the test.
- Using a low-power VPS where the NIC is shared and the vCPU is throttled, so CPU, not the network, is the limit.
- Comparing runs on different plans, at different times of day, or over different routes.
Re-run each configuration at least twice on separate days. A 15% improvement that disappears on the second day is noise. Keep notes of kernel version, qdisc, netem settings, and the exact iperf3 command line alongside each result.
Applying the result to production
If BBR3 wins on your real path, enable it permanently with net.ipv4.tcp_congestion_control=bbr and net.core.default_qdisc=fq in a sysctl drop-in, then apply with sysctl --system. Keep CUBIC as the fallback in the list so the system still boots cleanly if the module fails to load. Verify with ss -tin that established connections actually report bbr.
Test with your application’s traffic shape, not only iperf3. A site serving many short requests gains little from BBR3, while a video or backup workload on a lossy path gains a lot. If the host itself is the limit, a plan with a larger port and more vCPU does more than any algorithm choice — see the VPS versus dedicated comparison for where that threshold sits, then review VPS hosting options with measured throughput figures.




Leave a Reply
You must be logged in to post a comment.