The initial TCP slow start phase seeks to ramp up data transmission rates quickly to meet available capacity but also to exit the slow start phase before causing undue congestion. Unfortunately, the typical default TCP implementation often exits slow start too early, before capacity has been reached, causing underutilization, particularly detrimental to networks with large capacities and high delays. This study introduces a novel enhancement to TCP slow start - Slow start Exit At Right CHokepoint (SEARCH) - where the link capacity is inferred at the server based on bytes delivered compared to the expected bytes delivered, smoothed to account for link latency variation and normalized to accommodate link capacities. Empirical evaluation over geosynchronous satellite links, low-orbit satellite links, and 4G LTE links shows our approach is a substantial improvement over default TCP implementations by not exiting slow start too early, but better than traditional TCP, too, by exiting slow start before encountering packet loss.

The Slow start Exit At Right CHokepoint (SEARCH) algorithm is designed to exit the TCP slow start phase after the flow has reached the link capacity but before packets have been lost. To do this, SEARCH keeps a history of the bytes delivered over a recent time window, aggregated into bins. Unfortunately, this delivery history must be kept per-flow, adding additional memory load for each TCP connection. We address this per-flow memory load by observing that SEARCH only needs the relative number of bytes delivered and propose a bit-shifting technique that dynamically compresses bin values as needed. Our approach is tunable to the memory-use reduction required compared to the delivery precision needed. Evaluation of our approach over a satellite network shows SEARCH bin memory use can be reduced by 50% or even 75% without any significant sacrifice in SEARCH algorithm accuracy. Our approach is generalizable to other network algorithms, too, reducing memory use for algorithms that use sliding windows and historical data tracking.

TCP’s slow start phase is particularly inefficient over most wireless networks, especially high-latency, high-bandwidth paths such as satellite networks, often exiting too early or too late (after packet loss). To address this, the Slow start Exit At CHokepoint (SEARCH) algorithm is designed to improve exit decisions during slow start by analyzing delivery trends across sliding RTT-based windows. This paper presents a first implementation of SEARCH in the FreeBSD kernel using FreeBSD’s modular congestion control framework. We evaluate our implementation on a testbed with an actual GEO satellite link with ~600 ms RTT and 150 Mb/s capacity. Preliminary results show that SEARCH exits slow start more effectively than HyStart and HyStart++, achieving higher throughput and better utilization.

QUIC is increasingly being deployed on the Internet as an alternative to TCP. However, QUIC over satellite links faces particular challenges as high and variable round-trip times (RTTs) make it difficult to determine and then reach link capacity. Standard slow start algorithms to detect link capacity can perform poorly over satellite links, often exiting slow start too early and limiting throughput or exiting too late and causing unnecessary packet loss. The Slow start Exit At Right CHokepoint (SEARCH) algorithm aims to exit slow start after reaching link capacity but before incurring packet loss by tracking delivery rates and exiting when rates have not increased by the expected amount. SEARCH has shown benefits over traditional slow start for TCP connections but has yet to be implemented and evaluated in QUIC. This paper presents the design and implementation of SEARCH in an open-source QUIC library, with the code publicly available as a contribution. Evaluation of SEARCH over a geostationary satellite link show SEARCH successfully exits slow start before loss in the majority of cases, Improving goodput compared to the baseline.

TCP slow start begins at a conservative bitrate but quickly ramps up to the available bandwidth. Unfortunately, current TCP implementations can either: 1) exit from slow start prematurely, which is especially detrimental to utilization on satellite links, or 2) exit from slow start too late, causing unnecessary packet loss. We propose a novel technique to exit slow start while avoiding both premature and belated exits. We evaluate our approach over commercial satellite links - long, fat networks that pose challenges to determining the right slow start exit time. Preliminary results show a high success rate for picking appropriate exit points over satellite links, with potentially being applicable to other types of networks, more generally.