fix(client): throttle recursive polling during active streams

Author: nightowlnerd

crates/slipstream-client/src/dns/resolver.rs

@@ -62,6 +62,7 @@ pub(crate) struct ResolverState {
     pub(crate) active_refresh_suspect_count: u8,
     pub(crate) active_delete_first_at: u64,
     pub(crate) last_progress_at: u64,
+    pub(crate) last_recursive_poll_sent_at: u64,
 }
 
 impl ResolverState {
@@ -143,6 +144,7 @@ impl ResolverManager {
             resolver.active_refresh_suspect_count = 0;
             resolver.active_delete_first_at = 0;
             resolver.last_progress_at = 0;
+            resolver.last_recursive_poll_sent_at = 0;
         }
     }
 
@@ -323,6 +325,7 @@ pub(crate) fn resolve_resolvers(
             active_refresh_suspect_count: 0,
             active_delete_first_at: 0,
             last_progress_at: 0,
+            last_recursive_poll_sent_at: 0,
         });
     }
     Ok(resolved)
@@ -353,6 +356,7 @@ pub(crate) fn reset_resolver_path(resolver: &mut ResolverState) {
     resolver.active_delete_suspect_count = 0;
     resolver.active_refresh_suspect_count = 0;
     resolver.active_delete_first_at = 0;
+    resolver.last_recursive_poll_sent_at = 0;
 }
 
 pub(crate) fn clear_active_path_suspect(resolver: &mut ResolverState) {

crates/slipstream-client/src/runtime.rs

@@ -896,7 +896,15 @@ pub async fn run_client(config: &ClientConfig<'_>) -> Result<i32, ClientError> {
                             dns_id: &mut dns_id,
                             send_buf: &mut send_buf,
                         };
-                        poll_recursive_resolver(cnx, &mut dispatch, resolver).await?;
+                        poll_recursive_resolver(
+                            cnx,
+                            &mut dispatch,
+                            resolver,
+                            has_ready_stream,
+                            flow_blocked,
+                            sent_quic_data,
+                        )
+                        .await?;
                     }
                 }
             }

crates/slipstream-client/src/runtime/actions.rs

@@ -8,6 +8,11 @@ use tracing::debug;
 
 use super::path::{fetch_path_quality, path_poll_burst_max};
 
+const RECURSIVE_POLL_MIN_INTERVAL_US_ACTIVE: u64 = 5_000;
+const RECURSIVE_POLL_MIN_INTERVAL_US_IDLE: u64 = 1_000;
+const RECURSIVE_POLL_BURST_ACTIVE_STREAMS: usize = 1;
+const RECURSIVE_POLL_BURST_IDLE: usize = 4;
+
 pub(crate) struct PollDispatch<'a, 'cfg> {
     pub(crate) udp: &'a TokioUdpSocket,
     pub(crate) config: &'a ClientConfig<'cfg>,
@@ -77,6 +82,9 @@ pub(crate) async fn poll_recursive_resolver(
     cnx: *mut picoquic_cnx_t,
     dispatch: &mut PollDispatch<'_, '_>,
     resolver: &mut ResolverState,
+    has_ready_stream: bool,
+    flow_blocked: bool,
+    sent_quic_data: bool,
 ) -> Result<(), ClientError> {
     if resolver.mode != ResolverMode::Recursive {
         return Ok(());
@@ -87,7 +95,30 @@ pub(crate) async fn poll_recursive_resolver(
         return Ok(());
     }
 
+    let now = unsafe { slipstream_ffi::picoquic::picoquic_current_time() };
+    let min_interval = if has_ready_stream {
+        RECURSIVE_POLL_MIN_INTERVAL_US_ACTIVE
+    } else {
+        RECURSIVE_POLL_MIN_INTERVAL_US_IDLE
+    };
+    if resolver.last_recursive_poll_sent_at > 0
+        && now.saturating_sub(resolver.last_recursive_poll_sent_at) < min_interval
+    {
+        return Ok(());
+    }
+
+    if has_ready_stream && !flow_blocked && sent_quic_data {
+        return Ok(());
+    }
+
     let burst_max = path_poll_burst_max(resolver);
+    let burst_cap = if has_ready_stream {
+        RECURSIVE_POLL_BURST_ACTIVE_STREAMS
+    } else {
+        RECURSIVE_POLL_BURST_IDLE
+    };
+    let burst_max = burst_max.min(burst_cap.max(1));
+    let polls_sent_before = resolver.debug.polls_sent;
     if resolver.pending_polls > burst_max {
         let mut to_send = burst_max;
         send_poll_queries(
@@ -121,5 +152,9 @@ pub(crate) async fn poll_recursive_resolver(
         resolver.pending_polls = pending;
     }
 
+    if resolver.debug.polls_sent > polls_sent_before {
+        resolver.last_recursive_poll_sent_at = now;
+    }
+
     Ok(())
 }