The internet's foundational congestion control mechanism, classic TCP, relies on a simple, cooperative assumption: every endpoint speaks the same language. When a bottleneck router's queue fills up and drops a packet, the sending endpoint interprets this loss as a signal to halve its transmission rate. If every flow adheres to this Additive Increase Multiplicative Decrease (AIMD) behavior, the network naturally converges toward an equitable distribution of bandwidth.
However, the modern internet is no longer a homogeneous ecosystem. Applications now deploy a diverse array of transport mechanisms optimized for specific use cases: high-throughput UDP variants for big data, multipath protocols for mobile devices, and aggressive "hot-start" algorithms for web services.
When these heterogeneous protocols meet at a shared bottleneck queue, the cooperative assumption breaks down. Fairness is not an inherent property of a protocol in isolation; it is an emergent property of how different control loops interact through a shared buffer. Understanding cross-protocol fairness requires looking under the hood at how diverse traffic signatures alter the very congestion signals they rely on.
The Illusion of Isolated Friendliness
A common approach to designing a new transport protocol is to make it mathematically "TCP-friendly"—ensuring that, under a given loss rate, its theoretical throughput formula matches that of standard TCP. However, as Jean-Yves Le Boudec demonstrates in On the long-run behavior of equation-based rate control, this theoretical isolation does not translate to fairness in practice.
Equation-based protocols (like TFRC) deliberately smooth out their sending rates to avoid TCP's jagged, saw-tooth throughput patterns. But this smooth traffic signature changes the physical dynamics of the bottleneck queue. Because the equation-based traffic is less bursty, it alters the aggregate packet drop patterns, causing the equation-based flows to experience a lower overall loss rate than the competing, bursty TCP flows. Consequently, the smoother protocol inadvertently captures an unfair share of the bandwidth, proving that protocols cannot be evaluated independently of the traffic signatures they compete against.
This competitive imbalance is exacerbated by protocols that employ aggressive bandwidth estimation or initialization parameters. For instance, the transport variants analyzed by Uttam in TCP- Costco Reno: New Variant by Improving Bandwidth Estimation to adapt over MANETs utilize aggressive estimation techniques to maximize throughput in volatile wireless environments, which risks starving legacy traffic on shared links.
Similarly, the "hot-start" mechanisms evaluated by Jia Zhang et al. in Cold Start or Hot Start? Robust Slow Start in Congestion Control with A Priori Knowledge for Mobile Web Services bypass traditional, cautious slow-start phases by using historical network data to immediately inject large congestion windows into the network. When multiple aggressive or high-performance protocols—such as UDT, introduced by Yunhong Gu et al. in Teraflows over Gigabit WANs with UDT—compete over extended periods or across complex routed paths, their mutual competition can destabilize the bottleneck link, leading to high throughput variance and severe fairness degradation for standard traffic.
The Structural Footprint of Multipath and Aggregates
Fairness challenges multiply when an application or protocol alters its structural footprint within the network. If a protocol opens multiple concurrent paths or pools connections, it inherently occupies more slots in the bottleneck queue than a single-path competitor.
Multipath TCP (MPTCP) splits a single data stream across multiple network interfaces (e.g., Wi-Fi and Cellular). As surveyed by Maisha Maliha et al. in A Survey on Congestion Control and Scheduling for Multipath TCP: Machine Learning vs Classical Approaches, if these subflows act independently, they will treat a shared bottleneck link as multiple distinct resources, effectively stealing bandwidth from single-path users. To prevent this, multipath protocols must implement coupled congestion control, dynamically shifting traffic away from congested bottlenecks to ensure that the aggregate multipath flow behaves no more aggressively than a single standard TCP flow.
To formalize this balance, Andreas Könsgen et al. developed a mathematical model in A Mathematical Model for Efficient and Fair Resource Assignment in Multipath Transport using mixed-integer nonlinear programming to optimally allocate link capacities, ensuring that multi-flow connections do not dominate standard traffic.
Uncoupled Multipath (Unfair):
Path 1 (Bottleneck) ---> [Subflow A (TCP-like)] + [Single-Path TCP] -> Subflow A takes 50%
Path 2 (Bottleneck) ---> [Subflow B (TCP-like)] -> Subflow B takes 100%
Total MPTCP Allocation = 150% vs Single-Path TCP = 50%
Coupled Multipath (Fair):
Path 1 (Bottleneck) ---> [Subflow A (Throttled)] + [Single-Path TCP] -> Subflow A backs off
Path 2 (Clear Path) ---> [Subflow B (Aggressive)] -> Shifts weight here
Even with coupling, interoperability friction remains an open problem. For example, Jiangping Han et al. demonstrate in Leveraging Coupled BBR and Adaptive Packet Scheduling to Boost MPTCP that coordinating delay- and bandwidth-aware algorithms (like BBR) across multiple subflows while maintaining equity with traditional loss-based, single-path flows introduces severe cross-protocol coordination complexities.
This structural advantage is not confined to the transport layer; application-level behavior can mimic multipath unfairness. As noted by Wenfei Wu et al. in Adaptive data transmission in the cloud, applications that open numerous parallel connections naturally capture a disproportionate share of bandwidth compared to applications using fewer connections.
When managing these connection groups as a single unit, traditional mechanisms falter. In Probe-Aided MulTCP: an aggregate congestion control mechanism, Fang-Chun Kuo et al. show that aggregate congestion control mechanisms often oscillate between two extremes: either monopolizing the bottleneck link or being starved by individual flows, requiring explicit probing loops to stabilize bandwidth distribution.
Even within a single protocol family, scaling the sheer volume of concurrent connections can break fairness assumptions. As demonstrated by Lili Qiu et al. in Understanding the performance of many TCP flows, when a massive number of standard TCP connections compete in a "small pipe" environment (where the bandwidth-delay product is small relative to the flow count), the network experiences global synchronization. A small subset of connections captures the majority of the buffer space, while the remaining flows suffer frequent timeouts and total starvation.
The Unregulated Frontier of UDP Traffic
The most severe cross-protocol conflicts occur when congestion-aware protocols compete with non-adaptive traffic. Because UDP lacks a native, hardcoded congestion control loop, applications running over UDP are not bound by the voluntary back-off rules of TCP.
When high-bandwidth media delivery systems prioritize raw throughput over network cooperation, they create a severe resource imbalance. In Scalable WiFi Media Delivery through Adaptive Broadcasts, Sayandeep Sen highlights this "multicast bottleneck" in wireless environments, where unmanaged UDP video streams can monopolize shared links and cause the performance of concurrent, congestion-aware web traffic to collapse.
Even when developers implement custom throttling mechanisms over UDP, they often lack strict TCP-friendliness. Davide Frey et al. demonstrate in Heterogeneous Gossip that application-level protocols designed to optimize internal workloads can compete aggressively with other applications on the same host, starving co-located traffic due to a lack of standardized, cross-protocol coordination.
Shared Bottleneck Link:
[TCP Flow] --------> (Halves rate on loss) -----\
===> [ Router Buffer ] ---> Starvation for TCP
[Unmanaged UDP] ---> (Ignores loss, keeps rate) -/
To resolve this without requiring modifications to end-user applications, researchers have explored network-layer enforcement. In Fudp: an SDN-based Mechanism for Controlling UDP flows, Hui Hu et al. propose a Software-Defined Networking (SDN) architecture that shifts the burden of fairness from the endpoints to a centralized controller. By monitoring traffic signatures at the switch level, the system dynamically rate-limits non-adaptive UDP flows, forcing them to behave in a "quasi-TCP-friendly" manner and preserving bandwidth for standard protocols.
Network-Side Enforcement and Architectural Barriers
When endpoints cannot or will not cooperate, the responsibility for ensuring fairness falls on the underlying network infrastructure. However, routers and switches face severe architectural and physical constraints that complicate this enforcement.
Traditional Active Queue Management (AQM) schemes like RED or Drop-Tail treat packets identically regardless of their origin, which inherently disadvantages certain traffic profiles. As Konstantin Avrachenkov et al. explain in Congestion control of TCP flows in Internet routers by means of index policy, standard queues disproportionately penalize flows with longer Round-Trip Times (RTTs) or desynchronize competing variants, requiring routers to employ advanced scheduling heuristics (such as index policies) to balance the scales.
Furthermore, if the feedback signals sent back to endpoints are coarse or imprecise, certain flows will still capture an unfair share of the link. To fix this, Homayoun Yousefi’zadeh introduces MPCP in MPCP, a protocol that distributes precise congestion information across multiple packets using standard Explicit Congestion Notification (ECN) bits, allowing diverse flows to converge on fair allocations faster.
At the hardware level, implementing true fair queuing is often computationally prohibitive. George Varghese points out in Measurement Based Fair Queuing for Allocating Bandwidth to Virtual Machines that modern software-based virtual switches and batched Network Interface Card (NIC) transmissions break the core mathematical assumptions of classical fair queuing algorithms. Enforcing isolation in cloud environments without overwhelming the host CPU requires separating coarse-grained periodic adjustments from fine-grained packet pacing.
Classical Fair Queuing:
Per-packet processing overhead -> Scales poorly with high-speed batched NICs
Measurement-Based Fair Queuing (MBFQ):
[Macroscheduler: Periodic Weight Adjustments] --> Low CPU Overhead
[Microscheduler: Fine-Grained Packet Pacing] --> High Efficiency
When hardware designers cut costs to save buffer space, fairness is often the first casualty. In Cost / Performance Trade-Offs and Fairness Evaluation of Queue Mapping Policies, Teresa Nachiondo Frinós et al. evaluate Destination-Based Buffer Management (DBBM), demonstrating that reducing the number of physical queues in interconnection networks introduces unpredictable flow contention. When multiple distinct traffic streams are forced to share a limited set of queues, certain flows receive disproportionately less bandwidth based entirely on the underlying network topology and routing algorithms.
This spatial and topological unfairness reaches its peak in Mobile Ad Hoc Networks (MANETs). As surveyed by Hongqiang Zhai et al. in Medium access control in mobile ad hoc networks: challenges and solutions, achieving fairness for multi-hop wireless flows is an intricate, multi-layer problem. Because the wireless medium is shared spatially, Medium Access Control (MAC) layer contentions, routing decisions, and transport-layer congestion loops become deeply entangled. A flow traversing multiple hops can be completely starved by a single-hop neighbor, making cross-protocol fairness an architectural challenge spanning from physical hardware queues up to application-level transport loops.
Key Foundational Work
Understanding the performance of many TCP flows (2001) — contributed 2 concept elements to this direction.
Teraflows over Gigabit WANs with UDT (2005) — contributed 2 concept elements to this direction.
On the long-run behavior of equation-based rate control (2005) — contributed 2 concept elements to this direction.