feat(congestion-control): Implement BBR

Author: Jadon-Chan

Cargo.toml

@@ -93,6 +93,9 @@ defmt = ["dep:defmt", "heapless/defmt"]
 # Enable Reno TCP congestion control algorithm, and it is used as a default congestion controller.
 "socket-tcp-reno" = []
 
+# Enable BBR TCP congestion control algorithm, and it is used as a default congestion controller.
+"socket-tcp-bbr" = []
+
 "packetmeta-id" = []
 
 "async" = []

examples/client.rs

@@ -31,7 +31,7 @@ fn main() {
     // Create interface
     let mut config = match device.capabilities().medium {
         Medium::Ethernet => {
-            Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into())
+            Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]).into())
         }
         Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip),
         Medium::Ieee802154 => todo!(),
@@ -41,7 +41,7 @@ fn main() {
     let mut iface = Interface::new(config, &mut device, Instant::now());
     iface.update_ip_addrs(|ip_addrs| {
         ip_addrs
-            .push(IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24))
+            .push(IpCidr::new(IpAddress::v4(192, 168, 69, 2), 24))
             .unwrap();
         ip_addrs
             .push(IpCidr::new(IpAddress::v6(0xfdaa, 0, 0, 0, 0, 0, 0, 1), 64))

src/socket/tcp.rs

@@ -161,6 +161,11 @@ const RTTE_MIN_RTO: u32 = 1000;
 // seconds
 const RTTE_MAX_RTO: u32 = 60_000;
 
+// BBR: Window length for min_rtt filter (in seconds)
+// This matches the Linux kernel BBR implementation (tcp_bbr.c:135)
+#[cfg(feature = "socket-tcp-bbr")]
+const BBR_MIN_RTT_WIN_SEC: u64 = 10;
+
 #[derive(Debug, Clone, Copy)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 struct RttEstimator {
@@ -176,6 +181,12 @@ struct RttEstimator {
     timestamp: Option<(Instant, TcpSeqNumber)>,
     max_seq_sent: Option<TcpSeqNumber>,
     rto_count: u8,
+    /// BBR: Minimum RTT observed in the last 10 seconds
+    #[cfg(feature = "socket-tcp-bbr")]
+    min_rtt_value: u32,
+    /// BBR: Timestamp when min_rtt was last updated
+    #[cfg(feature = "socket-tcp-bbr")]
+    min_rtt_stamp: Option<Instant>,
 }
 
 impl Default for RttEstimator {
@@ -188,6 +199,10 @@ impl Default for RttEstimator {
             timestamp: None,
             max_seq_sent: None,
             rto_count: 0,
+            #[cfg(feature = "socket-tcp-bbr")]
+            min_rtt_value: u32::MAX,
+            #[cfg(feature = "socket-tcp-bbr")]
+            min_rtt_stamp: None,
         }
     }
 }
@@ -197,7 +212,33 @@ impl RttEstimator {
         Duration::from_millis(self.rto as _)
     }
 
-    fn sample(&mut self, new_rtt: u32) {
+    #[cfg(feature = "socket-tcp-bbr")]
+    pub(super) fn min_rtt(&self) -> Duration {
+        // Return the actual minimum RTT observed in the window, not SRTT
+        // If no measurement yet, fall back to SRTT as a reasonable estimate
+        if self.min_rtt_value == u32::MAX {
+            Duration::from_millis(self.srtt as _)
+        } else {
+            Duration::from_millis(self.min_rtt_value as _)
+        }
+    }
+
+    #[cfg(feature = "socket-tcp-bbr")]
+    pub(super) fn is_min_rtt_expired(&self, now: Instant) -> bool {
+        // Check if the min_rtt window has expired (10 seconds)
+        // This matches Linux kernel BBR behavior (tcp_bbr.c:948-949)
+        if let Some(stamp) = self.min_rtt_stamp {
+            if now >= stamp {
+                (now - stamp) > Duration::from_secs(BBR_MIN_RTT_WIN_SEC)
+            } else {
+                false // Time went backwards, don't consider expired
+            }
+        } else {
+            true // No measurement yet, consider expired
+        }
+    }
+
+    fn sample(&mut self, new_rtt: u32, #[allow(unused_variables)] now: Instant) {
         if self.have_measurement {
             // RFC 6298 (2.3) When a subsequent RTT measurement R' is made, a host MUST set (...)
             let diff = (self.srtt as i32 - new_rtt as i32).unsigned_abs();
@@ -216,6 +257,27 @@ impl RttEstimator {
 
         self.rto_count = 0;
 
+        // BBR: Track minimum RTT in a sliding 10-second window
+        // This matches Linux kernel BBR behavior (tcp_bbr.c:947-955)
+        #[cfg(feature = "socket-tcp-bbr")]
+        {
+            let expired = self.is_min_rtt_expired(now);
+
+            // Update min_rtt if:
+            // 1. New sample is lower than current minimum, OR
+            // 2. The window has expired (need fresh measurement)
+            if new_rtt < self.min_rtt_value || expired {
+                self.min_rtt_value = new_rtt;
+                self.min_rtt_stamp = Some(now);
+
+                tcp_trace!(
+                    "rtte: min_rtt updated to {:?}ms (expired={})",
+                    new_rtt,
+                    expired
+                );
+            }
+        }
+
         tcp_trace!(
             "rtte: sample={:?} srtt={:?} rttvar={:?} rto={:?}",
             new_rtt,
@@ -242,7 +304,7 @@ impl RttEstimator {
     fn on_ack(&mut self, timestamp: Instant, seq: TcpSeqNumber) {
         if let Some((sent_timestamp, sent_seq)) = self.timestamp {
             if seq >= sent_seq {
-                self.sample((timestamp - sent_timestamp).total_millis() as u32);
+                self.sample((timestamp - sent_timestamp).total_millis() as u32, timestamp);
                 self.timestamp = None;
             }
         }
@@ -454,6 +516,9 @@ pub enum CongestionControl {
 
     #[cfg(feature = "socket-tcp-cubic")]
     Cubic,
+
+    #[cfg(feature = "socket-tcp-bbr")]
+    Bbr,
 }
 
 /// A Transmission Control Protocol socket.
@@ -657,6 +722,9 @@ impl<'a> Socket<'a> {
 
             #[cfg(feature = "socket-tcp-cubic")]
             CongestionControl::Cubic => AnyController::Cubic(cubic::Cubic::new()),
+
+            #[cfg(feature = "socket-tcp-bbr")]
+            CongestionControl::Bbr => AnyController::Bbr(bbr::Bbr::new()),
         }
     }
 
@@ -672,6 +740,9 @@ impl<'a> Socket<'a> {
 
             #[cfg(feature = "socket-tcp-cubic")]
             AnyController::Cubic(_) => CongestionControl::Cubic,
+
+            #[cfg(feature = "socket-tcp-bbr")]
+            AnyController::Bbr(_) => CongestionControl::Bbr,
         }
     }
 
@@ -2368,6 +2439,12 @@ impl<'a> Socket<'a> {
             .inner_mut()
             .pre_transmit(cx.now());
 
+        // Notify congestion controller about available data for app-limited tracking
+        let bytes_available = self.tx_buffer.len();
+        self.congestion_controller
+            .inner_mut()
+            .on_send_ready(cx.now(), bytes_available);
+
         // Check if any state needs to be changed because of a timer.
         if self.timed_out(cx.now()) {
             // If a timeout expires, we should abort the connection.
@@ -8570,9 +8647,11 @@ mod test {
             2076, 2060, 2048, 2036, 2028, 2024, 2020, 2016, 2012, 2012,
         ];
 
+        let mut now = Instant::from_millis(0);
         for &rto in rtos {
-            r.sample(2000);
+            r.sample(2000, now);
             assert_eq!(r.retransmission_timeout(), Duration::from_millis(rto));
+            now += Duration::from_millis(100); // Advance time
         }
     }
 

src/socket/tcp/congestion.rs

@@ -10,6 +10,9 @@ pub(super) mod cubic;
 #[cfg(feature = "socket-tcp-reno")]
 pub(super) mod reno;
 
+#[cfg(feature = "socket-tcp-bbr")]
+pub(super) mod bbr;
+
 #[allow(unused_variables)]
 pub(super) trait Controller {
     /// Returns the number of bytes that can be sent.
@@ -30,10 +33,17 @@ pub(super) trait Controller {
 
     /// Set the maximum segment size.
     fn set_mss(&mut self, mss: usize) {}
+
+    /// Called when the socket is about to send data.
+    /// `bytes_available` indicates how many bytes are waiting in the send buffer.
+    /// This allows the congestion controller to track whether the application
+    /// is app-limited (not enough data to send) or cwnd-limited.
+    fn on_send_ready(&mut self, now: Instant, bytes_available: usize) {}
 }
 
 #[derive(Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[allow(clippy::large_enum_variant)]
 pub(super) enum AnyController {
     None(no_control::NoControl),
 
@@ -42,15 +52,20 @@ pub(super) enum AnyController {
 
     #[cfg(feature = "socket-tcp-cubic")]
     Cubic(cubic::Cubic),
+
+    #[cfg(feature = "socket-tcp-bbr")]
+    Bbr(bbr::Bbr),
 }
 
 impl AnyController {
     /// Create a new congestion controller.
     /// `AnyController::new()` selects the best congestion controller based on the features.
     ///
+    /// - If `socket-tcp-bbr` feature is enabled, it will use `Bbr`.
     /// - If `socket-tcp-cubic` feature is enabled, it will use `Cubic`.
     /// - If `socket-tcp-reno` feature is enabled, it will use `Reno`.
-    /// - If both `socket-tcp-cubic` and `socket-tcp-reno` features are enabled, it will use `Cubic`.
+    /// - Priority: BBR > Cubic > Reno > NoControl
+    ///    - `BBR` is optimized for high bandwidth-delay product networks.
     ///    - `Cubic` is more efficient regarding throughput.
     ///    - `Reno` is more conservative and is suitable for low-power devices.
     /// - If no congestion controller is available, it will use `NoControl`.
@@ -60,6 +75,11 @@ impl AnyController {
     #[allow(unreachable_code)]
     #[inline]
     pub fn new() -> Self {
+        #[cfg(feature = "socket-tcp-bbr")]
+        {
+            return AnyController::Bbr(bbr::Bbr::new());
+        }
+
         #[cfg(feature = "socket-tcp-cubic")]
         {
             return AnyController::Cubic(cubic::Cubic::new());
@@ -83,6 +103,9 @@ impl AnyController {
 
             #[cfg(feature = "socket-tcp-cubic")]
             AnyController::Cubic(c) => c,
+
+            #[cfg(feature = "socket-tcp-bbr")]
+            AnyController::Bbr(b) => b,
         }
     }
 
@@ -96,6 +119,9 @@ impl AnyController {
 
             #[cfg(feature = "socket-tcp-cubic")]
             AnyController::Cubic(c) => c,
+
+            #[cfg(feature = "socket-tcp-bbr")]
+            AnyController::Bbr(b) => b,
         }
     }
 }