Merge branch 'main' into search

Signed-off-by: Oskar Mansfeld <git@omansfeld.net>

Author: omansfeld

neqo-transport/src/cc/mod.rs

@@ -231,6 +231,116 @@ impl CongestionController for CongestionControlImplementation {
     }
 }
 
+/// A concrete congestion controller, dispatching across all combinations of
+/// algorithm and slow-start strategy.
+///
+/// This enum avoids the heap allocation and vtable indirection of `Box<dyn CongestionController>`
+/// on the per-packet hot path.
+#[derive(Debug, strum::Display)]
+pub enum CongestionControlImplementation {
+    #[strum(to_string = "{0}")]
+    ClassicNewReno(ClassicCongestionController<ClassicSlowStart, NewReno>),
+    #[strum(to_string = "{0}")]
+    HyStartNewReno(ClassicCongestionController<HyStart, NewReno>),
+    #[strum(to_string = "{0}")]
+    ClassicCubic(ClassicCongestionController<ClassicSlowStart, Cubic>),
+    #[strum(to_string = "{0}")]
+    HyStartCubic(ClassicCongestionController<HyStart, Cubic>),
+}
+
+macro_rules! dispatch {
+    ($self:ident . $method:ident $args:tt) => {
+        neqo_common::dispatch!(
+            [ClassicNewReno, HyStartNewReno, ClassicCubic, HyStartCubic]
+            $self . $method $args
+        )
+    };
+}
+
+impl CongestionController for CongestionControlImplementation {
+    fn set_qlog(&mut self, qlog: Qlog) {
+        dispatch!(self.set_qlog(qlog));
+    }
+
+    fn cwnd(&self) -> usize {
+        dispatch!(self.cwnd())
+    }
+
+    fn bytes_in_flight(&self) -> usize {
+        dispatch!(self.bytes_in_flight())
+    }
+
+    fn cwnd_avail(&self) -> usize {
+        dispatch!(self.cwnd_avail())
+    }
+
+    fn cwnd_min(&self) -> usize {
+        dispatch!(self.cwnd_min())
+    }
+
+    fn pmtud(&self) -> &Pmtud {
+        dispatch!(self.pmtud())
+    }
+
+    fn pmtud_mut(&mut self) -> &mut Pmtud {
+        dispatch!(self.pmtud_mut())
+    }
+
+    fn on_packets_acked(
+        &mut self,
+        acked_pkts: &[sent::Packet],
+        rtt_est: &RttEstimate,
+        now: Instant,
+        cc_stats: &mut CongestionControlStats,
+    ) {
+        dispatch!(self.on_packets_acked(acked_pkts, rtt_est, now, cc_stats));
+    }
+
+    fn on_packets_lost(
+        &mut self,
+        first_rtt_sample_time: Option<Instant>,
+        prev_largest_acked_sent: Option<Instant>,
+        pto: Duration,
+        lost_packets: &[sent::Packet],
+        now: Instant,
+        cc_stats: &mut CongestionControlStats,
+    ) -> bool {
+        dispatch!(self.on_packets_lost(
+            first_rtt_sample_time,
+            prev_largest_acked_sent,
+            pto,
+            lost_packets,
+            now,
+            cc_stats,
+        ))
+    }
+
+    fn on_ecn_ce_received(
+        &mut self,
+        largest_acked_pkt: &sent::Packet,
+        now: Instant,
+        cc_stats: &mut CongestionControlStats,
+    ) -> bool {
+        dispatch!(self.on_ecn_ce_received(largest_acked_pkt, now, cc_stats))
+    }
+
+    fn recovery_packet(&self) -> bool {
+        dispatch!(self.recovery_packet())
+    }
+
+    fn discard(&mut self, pkt: &sent::Packet, now: Instant) {
+        dispatch!(self.discard(pkt, now));
+    }
+
+    fn on_packet_sent(&mut self, pkt: &sent::Packet, now: Instant) {
+        dispatch!(self.on_packet_sent(pkt, now));
+    }
+
+    fn discard_in_flight(&mut self, now: Instant) {
+        dispatch!(self.discard_in_flight(now));
+    }
+}
+
 #[cfg(test)]
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod tests;