BBR's Sharing Behavior with CUBIC and Reno

summary

The gist

TCP BBR’s behavior has been explained by various theoretical models, and in particular those that describe how it co-exists with other types of flows.

In short

The study evaluates steady-state and fluid models to understand how TCP BBR interacts with other traffic types like CUBIC and Reno over shared network links. While these models accurately describe BBRv1 behavior against single loss-based flows, they fail to capture complex dynamics in BBRv2 and BBRv3, especially concerning deep buffers and intra-flow fairness. This suggests current models need significant updates for newer versions.

Key concepts

Steady-State Model
This model explains BBR's behavior by looking at the long-term equilibrium of flows competing on a bottleneck link. It predicts that BBR becomes window-limited and ACK-clocked when competing with other traffic, but it doesn't account for how many other loss-based flows are present or how fairness is achieved.
Fluid Model
The fluid model simplifies the system by treating traffic as continuous flows rather than discrete packets. It captures key dynamics of BBRv1 and BBRv2 well for shallow to moderate buffer sizes but breaks down when dealing with very deep buffers, many competing flows, or complex fairness requirements.
BBRv3 Behavior
BBRv3 probes for bandwidth until loss or ECN rates exceed a threshold. Neither the steady-state nor fluid models were designed for this version, and they do not fully capture its performance in deep buffer settings or scenarios involving numerous flows, indicating a modeling gap.
Intra-flow Fairness
This refers to how BBR manages resource allocation among different flows that are all part of the same BBR flow. Existing models struggle to accurately predict this fairness when buffer sizes are large, suggesting a need for better mechanisms in congestion control policy design.

Terminology used across episodes

This episode discusses

The paper

BBR's Sharing Behavior with CUBIC and Reno · Read on arXiv

New York University Tandon School of Engineering

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: We're looking at the paper: "BBR's Sharing Behavior with CUBIC and Reno".

Jane: Here's the gist of the paper. TCP BBR’s behavior has been explained by various theoretical models, and in particular those that describe how it co-exists with other types of flows.

Tom: Our experiments confirm that the steady-state model accurately captures BBRv1 behavior, especially against single loss-based flows.

Jane: However, clear discrepancies between existing model predictions and BBRv3 behavior suggest the need for an updated or entirely new modeling approach for this latest version.

Tom: Model Evaluation Scope The paper systematically evaluates the most influential steady-state and fluid models describing BBR’s coexistence with loss-based flows over shared bottleneck links.

Title and authors: Tom: So we're looking at this paper now, "BBR's Sharing Behavior with CUBIC and Reno." It’s about how TCP BBR interacts when it’s sharing a bottleneck link with other congestion control algorithms like CUBIC and Reno.

Jane: Right, so the core idea here is testing two main theoretical models—a steady-state model and a fluid model—to see if they actually predict what BBR does in these shared situations. What we're hearing is that this paper looks at how BBR handles competing flows when there’s packet loss involved.

Lu: The authors are systematically evaluating the most influential steady-state and fluid models describing BBR’s coexistence with loss-based flows over shared bottleneck links, extending previous findings to more network scenarios, including the recently introduced BBRv3.

Meng: Extending evaluations is good for coverage, but what's the practical take? What does this actually mean when you're deploying something in production that needs to work reliably across different network conditions?

Lalam: The paper confirms that when comparing BBRv1 against a single loss-based flow, the steady-state model accurately captures BBRv1 behavior >

Tom: That’s a strong starting point for them. So, what’s the key finding from that steady-state model? What does it actually tell us about how BBR behaves when it's competing?

Lu: The key finding is that when BBRv1 flows compete with other traffic, it becomes window limited and ACK clocked, and sends packets at a rate determined by its inflight cap >

Jane: Window limited sounds like BBR is throttling itself based on how many packets are already in flight. But what about the fairness aspect? Does this model tell us if BBR gets a fair share of the link capacity when competing with other loss-based algorithms?

Tom: That’s where it gets specific. The steady-state model doesn't include any signal to infer how many competing loss-based flows there are, and it doesn't adapt to achieve equal shares or fairness >

Meng: So the theory is accurate for BBRv1 against one competitor, but if you have ten competitors, this model might just give you a rough guess without telling you if anyone is actually getting what they deserve.

Jane: And then there’s the fluid model. The paper says it successfully captures several key behaviors of BBRv1 and BBRv2 >

Tom: That means for those older versions, the fluid model does a pretty good job simulating the core dynamics using those differential equations they developed >

Lu: It uses differential equations to track things like the estimated bottleneck bandwidth, which is called BtlBw, and minimum round-trip time, which is RTprop, along with transitions between key phases like ProbeBW and ProbeRTT >

Title and authors: Jane: That sounds complex. Can you explain what that means for a driver on the road? How does tracking bandwidth estimation help someone actually feel the congestion?

Tom: It’s about how BBR estimates the available pipe size and adjusts its sending rate based on that estimate, which is captured by that equation they show, xi equals m prt i times w prt i tau i minus one minus m prt i times x pbw i >

Meng: That formula looks like a lot of moving parts. If I’m running this at scale, what do I need to monitor in that equation to know if my deployment is going to break?

Lu: The model simulates queue lengths, packet losses, and jitter by approximating BBR’s probing pulses with smooth sigmoidal functions and using discrete mode variables for the state machine >

Jane: So it turns BBR’s stepwise behavior into something continuous so they can use these equations. That sounds like a big step in making the model more realistic than just looking at discrete events >

Tom: It is, but the paper flags limitations there, especially when buffer sizes get really deep or when there are a lot of flows involved >

Jane: And what are those specific scenarios where that fluid model starts failing? Where does it lose its accuracy?

Lu: The fluid model shows limitations in scenarios involving deep buffers, large numbers of flows, or intra-flow fairness interactions >

Meng: Deep buffers and lots of flows. That’s what I worry about because real networks can have those conditions, and if the model isn't accurate there, it might give us a false sense of security when we deploy it >

Tom: So for BBRv3, which is the newest version, neither the steady-state nor the fluid model was originally designed for it >

Jane: That means even though they tested BBRv3 against these old models, they aren't sure if those established conclusions actually hold true when you move to that newer protocol version >

Lu: They suggest that neither model fully captures the behavior of the recently introduced BBRv3, particularly in deep buffer settings and scenarios involving numerous flows >

Jane: So the main message here is that we need a new modeling approach if we want to really understand how BBRv3 behaves in complex environments >

Tom: Exactly. The paper points out that existing theoretical models may require updates or entirely new modeling approaches to accurately represent BBRv3’s behavior >

Title and authors: Jane: And the limitations they found with intra-flow fairness and buffer occupancy highlight exactly where more research is needed for this topic >

Meng: I agree, if we want to build robust systems, we can't just rely on models that stop working when the traffic gets busy or complex >

Lu: The researchers are suggesting that existing theoretical models may require updates—or entirely new modeling approaches—to accurately represent BBRv3’s behavior >

Jane: So, for anyone listening who only cares about what this means for their day-to-day internet experience, it means we need better tools to predict how BBR will behave when the network gets really crowded or when different types of traffic are fighting for space >

Tom: That’s the big picture. We have these models that work well in simple cases against single loss-based flows, but they struggle with the complexity of real-world networks and newer protocol versions like BBRv3 >

Jane: And it sounds like the next step is building models that can handle those deep buffer settings and complex fairness issues they flagged >

Lu: The experiment artifacts are publicly available so that others may validate and build on these findings, which is a good thing for further research >

Meng: Yeah, having the data out there lets other engineers actually test these theories against real traffic patterns instead of just trusting the paper's simulation results >

Lalam: I’m pretty sure the core finding is that while BBRv1 and BBRv2 behaviors are well-modeled under certain conditions, we definitely need new frameworks for BBRv3 >

Tom: So to wrap up, this paper on "BBR's Sharing Behavior with CUBIC and Reno" confirms the steady state model works for single loss-based flows but shows the fluid model struggles with fairness and deep buffers, pointing toward the need for updated models to handle BBRv3 >

Jane: It’s a solid piece of work that shows us what's missing—the deep buffer effects and the lack of intra-flow fairness details—and it sets a clear direction for future modeling efforts >

Lu: We definitely need to keep pushing for those new approaches, especially since BBRv3 is out there now >

Meng: I'll be watching those papers closely to see if they start shipping models that actually handle the real-world deployment challenges they mentioned >

Lalam: I’m confident the direction this paper points toward updating or creating entirely new modeling frameworks for BBRv3 will be very important for understanding modern congestion control >

The paper's summary: Tom: So, to recap, this paper is looking at how BBR interacts when it’s sharing a connection with other common congestion control algorithms like CUBIC and Reno >

Jane: Right, so they set up these experiments to test two main theoretical ideas—a steady-state model and a fluid model—against what those algorithms actually do in a shared network situation >

Tom: The paper confirms that the steady-state model works pretty well when you compare BBRv1 against just one loss-based flow, which is good because it matches what we see experimentally >

Jane: But then they look at BBRv2 and find that the fluid model can capture some of those dynamics, but it starts struggling when things get complicated, like with deep buffers or a lot of competing flows >

Tom: And this is where the paper flags a real problem for us because neither model was actually designed to handle BBRv3, which is the newest version we're seeing in deployment >

Jane: So what they’re saying is that if you want to accurately predict how BBRv3 will perform in those crowded networks, you can’t just use the old models anymore; they suggest we need a whole new way to model it >

Tom: Exactly. The paper points out that existing theoretical models might need serious updates or entirely new frameworks to get right with BBRv3 >

Jane: And those limitations they found regarding how BBR handles intra-flow fairness and how buffer occupancy affects things are really important because they show us where we need to focus our next research efforts >

Tom: It means that if we want better congestion control policies, we have to incorporate these insights from the steady-state model, which is good since it’s more accurate than the fluid model when BBR flows compete with loss-based algorithms >

Jane: So what this changes for you on a day-to-day level is that it tells us why BBR might behave differently under heavy load or when there are many different types of traffic fighting for the same link capacity >

The paper's improvements: Tom: We just talked about how the existing models fall short for BBRv3 because they don't handle deep buffers or lots of flows well >

Jane: And now we’re looking at what the authors actually suggest to fix that, which is basically that we need a new modeling approach entirely >

Tom: So instead of just patching the old models, they are pushing for a completely different way to represent BBR behavior when it’s competing with CUBIC or Reno >

Jane: The paper says this new framework needs to specifically account for those tricky bits like how buffer occupancy matters and the specific fairness issues between different flows >

Tom: It’s about taking those ideas from the steady-state model, which we know works against a single loss-based flow, and trying to build something that handles all of that complexity >

Jane: The implication is that for anyone designing network traffic or building an AI system that relies on BBR, you can’t just rely on the old simulations anymore >

Tom: And if you want to deploy something at scale, like what Meng worries about, you need a model that actually predicts how it will behave when the network gets really busy and complex >

Jane: It means future work has to focus on developing these new tools so we can stop guessing how BBRv3 is going to perform in those deep buffer scenarios >

Tom: The authors are essentially saying the current path forward isn't just tweaking parameters, it’s building a new theoretical structure for this kind of congestion control behavior >

Jane: That points us toward needing more comprehensive experiments because they admit their current study is limited to bulk transfer traffic patterns and specific network settings >

Conclusion: Tom: So, we’re wrapping up on "BBR's Sharing Behavior with CUBIC and Reno," which basically confirmed that while BBRv1 works against a single loss-based flow, the fluid model gets messy when things get complex >

Jane: Right, so the main takeaway is that we can’t just rely on old models when we move to newer versions like BBRv3 because they don't capture those deep buffer effects or fairness issues properly >

Tom: The authors are really stressing that for anyone building AI systems or network protocols, you need to expect these existing tools to break down in high-load, complex environments >

Jane: It’s a clear signal that the next step isn't just refining the old equations but developing something completely new to handle this behavior correctly >

Tom: We saw that the steady-state model is better for single competitors because it tracks things like window limits and ACK clocking accurately, which is a good baseline for us to keep >

Jane: But we also have to remember the fluid model’s failure points—deep buffers and many flows—because if you deploy BBR in a really crowded network, that’s where you lose accuracy >

Tom: Meng, from an engineering standpoint, what does this mean for us when we are trying to actually deploy something? What breaks at scale? >

Meng: It means we need models that don't just work on clean benchmarks but actually simulate the real traffic patterns and buffer depths where things get really dense >

Jane: And Lalam, what’s your take on this paper’s direction for how we understand congestion control? >

Lalam: I’m very sure that the need for a new framework is correct because BBRv3 is out there now and it's showing behavior these old models just can't predict reliably >

Tom: So to wrap up, "BBR's Sharing Behavior with CUBIC and Reno" shows us where our theoretical tools are falling short when dealing with modern protocol versions like BBRv3 >

Jane: It sets a very clear direction for future work in modeling and suggests we need to keep pushing for those updated approaches that can handle deep buffer settings >

Tom: Next time, we’ll look at how AI is actually integrating into clinical medicine, because the tension there is something else entirely >

More episodes

← Home