feat: DPLPMTUD

neqo-transport/src/cc/cubic.rs

@@ -11,7 +11,7 @@ use std::{
 
 use neqo_common::qtrace;
 
-use crate::cc::{classic_cc::WindowAdjustment, MAX_DATAGRAM_SIZE_F64};
+use crate::cc::classic_cc::WindowAdjustment;
 
 // CUBIC congestion control
 
@@ -38,7 +38,7 @@ const EXPONENTIAL_GROWTH_REDUCTION: f64 = 2.0;
 /// Convert an integer congestion window value into a floating point value.
 /// This has the effect of reducing larger values to `1<<53`.
 /// If you have a congestion window that large, something is probably wrong.
-fn convert_to_f64(v: usize) -> f64 {
+pub fn convert_to_f64(v: usize) -> f64 {
     let mut f_64 = f64::from(u32::try_from(v >> 21).unwrap_or(u32::MAX));
     f_64 *= 2_097_152.0; // f_64 <<= 21
     f_64 += f64::from(u32::try_from(v & 0x1f_ffff).unwrap());
@@ -91,17 +91,17 @@ impl Cubic {
     ///
     /// From that equation we can calculate K as:
     /// K = cubic_root((W_max - W_cubic) / C / MSS);
-    fn calc_k(&self, curr_cwnd: f64) -> f64 {
-        ((self.w_max - curr_cwnd) / CUBIC_C / MAX_DATAGRAM_SIZE_F64).cbrt()
+    fn calc_k(&self, curr_cwnd: f64, mtu: usize) -> f64 {
+        ((self.w_max - curr_cwnd) / CUBIC_C / convert_to_f64(mtu)).cbrt()
     }
 
     /// W_cubic(t) = C*(t-K)^3 + W_max (Eq. 1)
     /// t is relative to the start of the congestion avoidance phase and it is in seconds.
-    fn w_cubic(&self, t: f64) -> f64 {
-        CUBIC_C * (t - self.k).powi(3) * MAX_DATAGRAM_SIZE_F64 + self.w_max
+    fn w_cubic(&self, t: f64, mtu: usize) -> f64 {
+        CUBIC_C * (t - self.k).powi(3) * convert_to_f64(mtu) + self.w_max
     }
 
-    fn start_epoch(&mut self, curr_cwnd_f64: f64, new_acked_f64: f64, now: Instant) {
+    fn start_epoch(&mut self, curr_cwnd_f64: f64, new_acked_f64: f64, mtu: usize, now: Instant) {
         self.ca_epoch_start = Some(now);
         // reset tcp_acked_bytes and estimated_tcp_cwnd;
         self.tcp_acked_bytes = new_acked_f64;
@@ -111,7 +111,7 @@ impl Cubic {
             self.k = 0.0;
         } else {
             self.w_max = self.last_max_cwnd;
-            self.k = self.calc_k(curr_cwnd_f64);
+            self.k = self.calc_k(curr_cwnd_f64, mtu);
         }
         qtrace!([self], "New epoch");
     }
@@ -126,13 +126,14 @@ impl WindowAdjustment for Cubic {
         curr_cwnd: usize,
         new_acked_bytes: usize,
         min_rtt: Duration,
+        mtu: usize,
         now: Instant,
     ) -> usize {
         let curr_cwnd_f64 = convert_to_f64(curr_cwnd);
         let new_acked_f64 = convert_to_f64(new_acked_bytes);
         if self.ca_epoch_start.is_none() {
             // This is a start of a new congestion avoidance phase.
-            self.start_epoch(curr_cwnd_f64, new_acked_f64, now);
+            self.start_epoch(curr_cwnd_f64, new_acked_f64, mtu, now);
         } else {
             self.tcp_acked_bytes += new_acked_f64;
         }
@@ -149,12 +150,13 @@ impl WindowAdjustment for Cubic {
                 }
             })
             .as_secs_f64();
-        let target_cubic = self.w_cubic(time_ca);
+        let target_cubic = self.w_cubic(time_ca, mtu);
 
+        let mtu = convert_to_f64(mtu);
         let tcp_cnt = self.estimated_tcp_cwnd / CUBIC_ALPHA;
         while self.tcp_acked_bytes > tcp_cnt {
             self.tcp_acked_bytes -= tcp_cnt;
-            self.estimated_tcp_cwnd += MAX_DATAGRAM_SIZE_F64;
+            self.estimated_tcp_cwnd += mtu;
         }
 
         let target_cwnd = target_cubic.max(self.estimated_tcp_cwnd);
@@ -165,24 +167,22 @@ impl WindowAdjustment for Cubic {
         // The amount of data required therefore reduces asymptotically as the target increases.
         // If the target is not significantly higher than the congestion window, require a very
         // large amount of acknowledged data (effectively block increases).
-        let mut acked_to_increase =
-            MAX_DATAGRAM_SIZE_F64 * curr_cwnd_f64 / (target_cwnd - curr_cwnd_f64).max(1.0);
+        let mut acked_to_increase = mtu * curr_cwnd_f64 / (target_cwnd - curr_cwnd_f64).max(1.0);
 
         // Limit increase to max 1 MSS per EXPONENTIAL_GROWTH_REDUCTION ack packets.
         // This effectively limits target_cwnd to (1 + 1 / EXPONENTIAL_GROWTH_REDUCTION) cwnd.
-        acked_to_increase =
-            acked_to_increase.max(EXPONENTIAL_GROWTH_REDUCTION * MAX_DATAGRAM_SIZE_F64);
+        acked_to_increase = acked_to_increase.max(EXPONENTIAL_GROWTH_REDUCTION * mtu);
         acked_to_increase as usize
     }
 
-    fn reduce_cwnd(&mut self, curr_cwnd: usize, acked_bytes: usize) -> (usize, usize) {
+    fn reduce_cwnd(&mut self, curr_cwnd: usize, acked_bytes: usize, mtu: usize) -> (usize, usize) {
         let curr_cwnd_f64 = convert_to_f64(curr_cwnd);
         // Fast Convergence
         // If congestion event occurs before the maximum congestion window before the last
         // congestion event, we reduce the the maximum congestion window and thereby W_max.
         // check cwnd + MAX_DATAGRAM_SIZE instead of cwnd because with cwnd in bytes, cwnd may be
         // slightly off.
-        self.last_max_cwnd = if curr_cwnd_f64 + MAX_DATAGRAM_SIZE_F64 < self.last_max_cwnd {
+        self.last_max_cwnd = if curr_cwnd_f64 + convert_to_f64(mtu) < self.last_max_cwnd {
             curr_cwnd_f64 * CUBIC_FAST_CONVERGENCE
         } else {
             curr_cwnd_f64

neqo-transport/src/cc/mod.rs

@@ -14,22 +14,18 @@ use std::{
 
 use neqo_common::qlog::NeqoQlog;
 
-use crate::{path::PATH_MTU_V6, recovery::SentPacket, rtt::RttEstimate, Error};
+use crate::{recovery::SentPacket, rtt::RttEstimate, Error};
 
 mod classic_cc;
 mod cubic;
 mod new_reno;
 
 pub use classic_cc::ClassicCongestionControl;
 #[cfg(test)]
-pub use classic_cc::{CWND_INITIAL, CWND_INITIAL_PKTS, CWND_MIN};
+pub use classic_cc::CWND_INITIAL_PKTS;
 pub use cubic::Cubic;
 pub use new_reno::NewReno;
 
-pub const MAX_DATAGRAM_SIZE: usize = PATH_MTU_V6;
-#[allow(clippy::cast_precision_loss)]
-pub const MAX_DATAGRAM_SIZE_F64: f64 = MAX_DATAGRAM_SIZE as f64;
-
 pub trait CongestionControl: Display + Debug {
     fn set_qlog(&mut self, qlog: NeqoQlog);
 
@@ -42,6 +38,12 @@ pub trait CongestionControl: Display + Debug {
     #[must_use]
     fn cwnd_avail(&self) -> usize;
 
+    #[must_use]
+    fn cwnd_min(&self) -> usize;
+
+    #[must_use]
+    fn cwnd_initial(&self) -> usize;
+
     fn on_packets_acked(&mut self, acked_pkts: &[SentPacket], rtt_est: &RttEstimate, now: Instant);
 
     /// Returns true if the congestion window was reduced.

neqo-transport/src/cc/new_reno.rs

@@ -29,12 +29,13 @@ impl WindowAdjustment for NewReno {
         curr_cwnd: usize,
         _new_acked_bytes: usize,
         _min_rtt: Duration,
+        _mtu: usize,
         _now: Instant,
     ) -> usize {
         curr_cwnd
     }
 
-    fn reduce_cwnd(&mut self, curr_cwnd: usize, acked_bytes: usize) -> (usize, usize) {
+    fn reduce_cwnd(&mut self, curr_cwnd: usize, acked_bytes: usize, _mtu: usize) -> (usize, usize) {
         (curr_cwnd / 2, acked_bytes / 2)
     }