Add acked packet count to connection stats to make short-term loss rate more precisely

apps/src/bin/quiche-server.rs

@@ -541,8 +541,14 @@ fn main() {
         continue_write = false;
         for client in clients.values_mut() {
             // Reduce max_send_burst by 25% if loss is increasing more than 0.1%.
-            let loss_rate =
-                client.conn.stats().lost as f64 / client.conn.stats().sent as f64;
+            let stats = client.conn.stats();
+            let finished = stats.acked.saturating_add(stats.lost);
+            let loss_rate = if finished == 0 {
+                0.0
+            } else {
+                stats.lost as f64 / finished as f64
+            };
+
             if loss_rate > client.loss_rate + 0.001 {
                 client.max_send_burst = client.max_send_burst / 4 * 3;
                 // Minimum bound of 10xMSS.

quiche/include/quiche.h

@@ -576,6 +576,9 @@ typedef struct {
     // The number of QUIC packets sent on this connection.
     size_t sent;
 
+    // The number of QUIC packets that were acked.
+    size_t acked;
+
     // The number of QUIC packets that were lost.
     size_t lost;
 

quiche/src/ffi.rs

@@ -1325,6 +1325,7 @@ pub extern "C" fn quiche_stream_iter_free(iter: *mut StreamIter) {
 pub struct Stats {
     recv: usize,
     sent: usize,
+    acked: usize,
     lost: usize,
     spurious_lost: usize,
     retrans: usize,
@@ -1373,6 +1374,7 @@ pub extern "C" fn quiche_conn_stats(conn: &Connection, out: &mut Stats) {
 
     out.recv = stats.recv;
     out.sent = stats.sent;
+    out.acked = stats.acked;
     out.lost = stats.lost;
     out.spurious_lost = stats.spurious_lost;
     out.retrans = stats.retrans;

quiche/src/lib.rs

@@ -1374,6 +1374,9 @@ where
     /// Total number of sent packets.
     sent_count: usize,
 
+    /// Total number of acked packets.
+    acked_count: usize,
+
     /// Total number of lost packets.
     lost_count: usize,
 
@@ -2089,6 +2092,7 @@ impl<F: BufFactory> Connection<F> {
 
             recv_count: 0,
             sent_count: 0,
+            acked_count: 0,
             lost_count: 0,
             spurious_lost_count: 0,
             retrans_count: 0,
@@ -7802,6 +7806,7 @@ impl<F: BufFactory> Connection<F> {
         Stats {
             recv: self.recv_count,
             sent: self.sent_count,
+            acked: self.acked_count,
             lost: self.lost_count,
             spurious_lost: self.spurious_lost_count,
             retrans: self.retrans_count,
@@ -8301,6 +8306,7 @@ impl<F: BufFactory> Connection<F> {
                     let OnAckReceivedOutcome {
                         lost_packets,
                         lost_bytes,
+                        acked_packets,
                         acked_bytes,
                         spurious_losses,
                     } = p.recovery.on_ack_received(
@@ -8329,6 +8335,7 @@ impl<F: BufFactory> Connection<F> {
 
                     self.lost_count += lost_packets;
                     self.lost_bytes += lost_bytes as u64;
+                    self.acked_count += acked_packets;
                     self.acked_bytes += acked_bytes as u64;
                     self.spurious_lost_count += spurious_losses;
                 }
@@ -9344,6 +9351,9 @@ pub struct Stats {
     /// The number of QUIC packets sent.
     pub sent: usize,
 
+    /// The number of QUIC packets that were acked.
+    pub acked: usize,
+
     /// The number of QUIC packets that were lost.
     pub lost: usize,
 

quiche/src/recovery/congestion/delivery_rate.rs

@@ -507,6 +507,7 @@ mod tests {
         assert_eq!(ack_outcome, OnAckReceivedOutcome {
             lost_packets: 0,
             lost_bytes: 0,
+            acked_packets: packet_count,
             acked_bytes: mss * packet_count,
             spurious_losses: 0,
         });

quiche/src/recovery/congestion/recovery.rs

@@ -102,6 +102,7 @@ struct RecoveryEpoch {
 }
 
 struct AckedDetectionResult {
+    acked_packets: usize,
     acked_bytes: usize,
     spurious_losses: usize,
     spurious_pkt_thresh: Option<u64>,
@@ -125,6 +126,7 @@ impl RecoveryEpoch {
     ) -> Result<AckedDetectionResult> {
         newly_acked.clear();
 
+        let mut acked_packets = 0;
         let mut acked_bytes = 0;
         let mut spurious_losses = 0;
         let mut spurious_pkt_thresh = None;
@@ -182,6 +184,8 @@ impl RecoveryEpoch {
                         has_in_flight_spurious_loss = true;
                     }
                 } else {
+                    acked_packets += 1;
+
                     if unacked.in_flight {
                         self.in_flight_count -= 1;
                         acked_bytes += unacked.size;
@@ -213,6 +217,7 @@ impl RecoveryEpoch {
         self.drain_acked_and_lost_packets(now - rtt_stats.rtt());
 
         Ok(AckedDetectionResult {
+            acked_packets,
             acked_bytes,
             spurious_losses,
             spurious_pkt_thresh,
@@ -677,6 +682,7 @@ impl RecoveryOps for LegacyRecovery {
         trace_id: &str,
     ) -> Result<OnAckReceivedOutcome> {
         let AckedDetectionResult {
+            acked_packets,
             acked_bytes,
             spurious_losses,
             spurious_pkt_thresh,
@@ -754,6 +760,7 @@ impl RecoveryOps for LegacyRecovery {
         Ok(OnAckReceivedOutcome {
             lost_packets,
             lost_bytes,
+            acked_packets,
             acked_bytes,
             spurious_losses,
         })

quiche/src/recovery/gcongestion/recovery.rs

@@ -119,6 +119,7 @@ struct RecoveryEpoch {
 }
 
 struct AckedDetectionResult {
+    acked_packets: usize,
     acked_bytes: usize,
     spurious_losses: usize,
     spurious_pkt_thresh: Option<u64>,
@@ -178,6 +179,7 @@ impl RecoveryEpoch {
     ) -> Result<AckedDetectionResult> {
         newly_acked.clear();
 
+        let mut acked_packets = 0;
         let mut acked_bytes = 0;
         let mut spurious_losses = 0;
         let mut spurious_pkt_thresh = None;
@@ -227,6 +229,8 @@ impl RecoveryEpoch {
                             ack_eliciting,
                             ..
                         } => {
+                            acked_packets += 1;
+
                             if in_flight {
                                 self.pkts_in_flight -= 1;
                                 acked_bytes += sent_bytes;
@@ -260,6 +264,7 @@ impl RecoveryEpoch {
         self.drain_acked_and_lost_packets();
 
         Ok(AckedDetectionResult {
+            acked_packets,
             acked_bytes,
             spurious_losses,
             spurious_pkt_thresh,
@@ -818,6 +823,7 @@ impl RecoveryOps for GRecovery {
         let prior_in_flight = self.bytes_in_flight.get();
 
         let AckedDetectionResult {
+            acked_packets,
             acked_bytes,
             spurious_losses,
             spurious_pkt_thresh,
@@ -836,6 +842,7 @@ impl RecoveryOps for GRecovery {
 
         if self.newly_acked.is_empty() {
             return Ok(OnAckReceivedOutcome {
+                acked_packets,
                 acked_bytes,
                 spurious_losses,
                 ..Default::default()
@@ -892,6 +899,7 @@ impl RecoveryOps for GRecovery {
         Ok(OnAckReceivedOutcome {
             lost_packets,
             lost_bytes,
+            acked_packets,
             acked_bytes,
             spurious_losses,
         })