Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
59 changes: 58 additions & 1 deletion rs/moq-net/benches/session.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand Down Expand Up @@ -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);
23 changes: 18 additions & 5 deletions rs/moq-net/tests/idle_session.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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};
Expand All @@ -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<Arc<AtomicUsize>>,
) -> (MockPair, moq_net::bandwidth::Consumer) {
let mut options = MockConnectOptions::new(version.parse::<Version>().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");
Expand All @@ -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;
Expand All @@ -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),
Expand Down
24 changes: 9 additions & 15 deletions rs/moq-net/tests/support/harness.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<D: moq_net::time::Driver + Send + 'static>(driver: D) -> Arc<AtomicUsize> {
let polls = Arc::new(AtomicUsize::new(0));
tokio::spawn(run(Counted {
driver,
polls: polls.clone(),
}));
polls
}

struct Counted<D> {
driver: D,
polls: Arc<AtomicUsize>,
Expand Down Expand Up @@ -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<Arc<AtomicUsize>>,
}

impl MockConnectOptions {
Expand All @@ -77,6 +69,7 @@ impl MockConnectOptions {
server_subscribe: None,
latency: std::time::Duration::ZERO,
stats: MockStats::default(),
server_polls: None,
}
}
}
Expand All @@ -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<AtomicUsize>,
}

/// Run the MoQ handshake over the mock transport, returning connected sessions.
Expand Down Expand Up @@ -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,
}
}

Expand Down
Loading