From e3c181488c6688e1d4d8b593571c1c7dbca6ff64 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 12 Oct 2026 21:55:58 -0700 Subject: [PATCH] test(net): backport opt-in poll counting and idle benchmark Backport #5401 to the release runner and restore the idle-session benchmark omitted from #5384. Only the idle regression requests a poll counter; ordinary session benchmarks remain uninstrumented. Co-Authored-By: GPT-6 --- rs/moq-net/benches/session.rs | 59 ++++++++++++++++++++++++++++- rs/moq-net/tests/idle_session.rs | 23 ++++++++--- rs/moq-net/tests/support/harness.rs | 24 +++++------- 3 files changed, 85 insertions(+), 21 deletions(-) diff --git a/rs/moq-net/benches/session.rs b/rs/moq-net/benches/session.rs index 4aaf8765d94..0a47f54cad7 100644 --- a/rs/moq-net/benches/session.rs +++ b/rs/moq-net/benches/session.rs @@ -36,6 +36,7 @@ use bytes::Bytes; use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; use moq_net::{Hop, Timestamp, Version, broadcast, cache, group, origin, track}; use support::harness::{MockConnectOptions, MockPair, connect_mock}; +use support::mock::MockStats; /// The lite draft production negotiates, the next one (opt-in), and the newest /// IETF draft. @@ -809,5 +810,61 @@ fn session(c: &mut Criterion) { ); } -criterion_group!(benches, session, withdrawal); +/// Viewer sessions to one relay, each holding a PROBE stream and otherwise idle. +struct IdleRoom { + _viewers: Vec<(MockPair, moq_net::bandwidth::Consumer)>, +} + +impl IdleRoom { + async fn new(sessions: usize) -> Self { + let (relay, driver) = origin::Producer::new(origin::Config::new(Hop::new(1).unwrap())); + tokio::spawn(support::harness::run(driver)); + let mut viewers = Vec::new(); + for _ in 0..sessions { + let mut options = MockConnectOptions::new("moq-lite-06".parse().unwrap()); + options.server_publish = Some(relay.consume()); + // A QUIC backend reports both, so the relay serves PROBE. + options.stats = MockStats { + estimated_send_rate: Some(1_000_000), + rtt: Some(Duration::from_millis(40)), + }; + let pair = connect_mock(options).await; + let mut probe = pair.client.recv_bandwidth().unwrap(); + probe.changed().await.unwrap(); + viewers.push((pair, probe)); + } + Self { _viewers: viewers } + } + + /// Let a second of protocol time pass per iteration. + async fn measure(&self, iters: u64) -> Duration { + let start = Instant::now(); + for _ in 0..iters { + tokio::time::sleep(Duration::from_secs(1)).await; + } + start.elapsed() + } +} + +fn idle(c: &mut Criterion) { + let mut group = c.benchmark_group("session_idle"); + for sessions in [1, 64, 1024] { + group.throughput(Throughput::Elements(sessions as u64)); + // Its own runtime, so its paused clock and its sessions end with the shape. + let rt = runtime(); + let mut room = None; + group.bench_function(BenchmarkId::from_parameter(format!("sessions={sessions}")), |b| { + let room = room.get_or_insert_with(|| { + rt.block_on(async { + tokio::time::pause(); + IdleRoom::new(sessions).await + }) + }); + b.iter_custom(|iters| rt.block_on(room.measure(iters))) + }); + } + group.finish(); +} + +criterion_group!(benches, session, withdrawal, idle); criterion_main!(benches); diff --git a/rs/moq-net/tests/idle_session.rs b/rs/moq-net/tests/idle_session.rs index fe14eb82c02..d2be8aef094 100644 --- a/rs/moq-net/tests/idle_session.rs +++ b/rs/moq-net/tests/idle_session.rs @@ -4,7 +4,13 @@ mod support; -use std::{sync::atomic::Ordering, time::Duration}; +use std::{ + sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }, + time::Duration, +}; use moq_net::{Hop, Version, bandwidth::Rate, origin}; use support::harness::{MockConnectOptions, MockPair, connect_mock}; @@ -24,11 +30,16 @@ const STATS: MockStats = MockStats { /// A viewer session whose server publishes `origin`, with the viewer's PROBE /// stream open (as a browser viewer keeps one) and its first report received. -async fn viewer(version: &str, origin: &origin::Producer) -> (MockPair, moq_net::bandwidth::Consumer) { +async fn viewer( + version: &str, + origin: &origin::Producer, + polls: Option>, +) -> (MockPair, moq_net::bandwidth::Consumer) { let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(origin.consume()); options.client_subscribe = Some(origin::Producer::new(origin::Config::new(Hop::new(2).unwrap())).0); options.stats = STATS; + options.server_polls = polls; let pair = connect_mock(options).await; let mut probe = pair.client.recv_bandwidth().expect("lite carries PROBE"); @@ -47,10 +58,12 @@ fn origin() -> origin::Producer { async fn idle_viewer_does_not_wake_the_server() { for version in VERSIONS { let origin = origin(); - let (pair, _probe) = viewer(version, &origin).await; + let polls = Arc::new(AtomicUsize::new(0)); + let (pair, _probe) = viewer(version, &origin, Some(polls.clone())).await; - let (polls, reads) = (&pair.server_polls, &pair.server_transport); + let reads = &pair.server_transport; let (start_polls, start_reads) = (polls.load(Ordering::Relaxed), reads.stats_reads()); + assert!(start_polls > 0, "the requested poll counter must observe the handshake"); tokio::time::sleep(IDLE).await; let polls = polls.load(Ordering::Relaxed) - start_polls; let reads = reads.stats_reads() - start_reads; @@ -69,7 +82,7 @@ async fn idle_viewer_does_not_wake_the_server() { async fn busy_viewer_sees_the_estimate_move() { for version in VERSIONS { let origin = origin(); - let (pair, mut probe) = viewer(version, &origin).await; + let (pair, mut probe) = viewer(version, &origin, None).await; pair.server_transport.set_stats(MockStats { estimated_send_rate: Some(2_000_000), diff --git a/rs/moq-net/tests/support/harness.rs b/rs/moq-net/tests/support/harness.rs index 9b1793ef559..091b7ac0b86 100644 --- a/rs/moq-net/tests/support/harness.rs +++ b/rs/moq-net/tests/support/harness.rs @@ -18,16 +18,6 @@ use super::mock::{MockSession, MockStats, create_mock_session_pair}; pub use moq_net::time::run; -/// Spawn a protocol driver, returning how many times it has been polled. -pub fn spawn_counted(driver: D) -> Arc { - let polls = Arc::new(AtomicUsize::new(0)); - tokio::spawn(run(Counted { - driver, - polls: polls.clone(), - })); - polls -} - struct Counted { driver: D, polls: Arc, @@ -64,6 +54,8 @@ pub struct MockConnectOptions { pub latency: std::time::Duration, /// What both transports report as their connection statistics. pub stats: MockStats, + /// Count server driver polls into this counter when supplied. + pub server_polls: Option>, } impl MockConnectOptions { @@ -77,6 +69,7 @@ impl MockConnectOptions { server_subscribe: None, latency: std::time::Duration::ZERO, stats: MockStats::default(), + server_polls: None, } } } @@ -90,8 +83,6 @@ pub struct MockPair { pub client_transport: MockSession, /// The server's end of the mock transport, for steering delivery. pub server_transport: MockSession, - /// How many times the server's driver has been polled. - pub server_polls: Arc, } /// Run the MoQ handshake over the mock transport, returning connected sessions. @@ -144,16 +135,19 @@ pub async fn connect_mock(opts: MockConnectOptions) -> MockPair { .accept(now(), server_transport) .await .expect("server handshake failed"); - (session, spawn_counted(driver)) + match opts.server_polls { + Some(polls) => drop(tokio::spawn(run(Counted { driver, polls }))), + None => drop(tokio::spawn(run(driver))), + } + session }; - let (client_session, (server_session, server_polls)) = tokio::join!(client_fut, server_fut); + let (client_session, server_session) = tokio::join!(client_fut, server_fut); MockPair { client: client_session, server: server_session, client_transport: transports.0, server_transport: transports.1, - server_polls, } }