feat(test-fixtures): add http3 support to Simulator

Enables benchmarking of mozilla#2796.

Fixes mozilla#2728.
Fixes mozilla#2804.

Author: mxinden

neqo-http3/Cargo.toml

@@ -49,9 +49,7 @@ ignored = ["log"]
 # See https://github.com/bheisler/criterion.rs/blob/master/book/src/faq.md#cargo-bench-gives-unrecognized-option-errors-for-valid-command-line-options
 bench = false
 
-# FIXME: These benches have a high rate of variability and are hence not very useful
-# in their current form. See https://github.com/mozilla/neqo/issues/2804
-# [[bench]]
-# name = "streams"
-# harness = false
-# required-features = ["bench"]
+[[bench]]
+name = "streams"
+harness = false
+required-features = ["bench"]

neqo-http3/benches/streams.rs

@@ -4,79 +4,66 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![expect(clippy::unwrap_used, reason = "OK in a bench.")]
+use std::{hint::black_box, time::Duration};
 
-use std::{hint::black_box, iter::repeat_with};
-
-use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
-use neqo_crypto::AuthenticationStatus;
-use neqo_http3::{Http3Client, Http3Parameters, Http3Server, Priority};
-use neqo_transport::{ConnectionParameters, StreamType};
+use criterion::{criterion_group, criterion_main, Criterion, Throughput};
 use test_fixture::{
-    fixture_init, http3_client_with_params, http3_server_with_params, now, DEFAULT_SERVER_NAME,
+    boxed, fixture_init,
+    sim::{
+        http3_connection::{Node, Requests, Responses},
+        network::{RandomDelay, TailDrop},
+        ReadySimulator, Simulator,
+    },
 };
 
-const STREAM_TYPE: StreamType = StreamType::BiDi;
-const STREAMS_MAX: u64 = 1 << 60;
-
-fn use_streams(client: &mut Http3Client, server: &mut Http3Server, streams: usize, data: &[u8]) {
-    let stream_ids = repeat_with(|| {
-        client
-            .fetch(
-                now(),
-                "GET",
-                &("https", DEFAULT_SERVER_NAME, "/"),
-                &[],
-                Priority::default(),
-            )
-            .unwrap()
-    })
-    .take(streams)
-    .collect::<Vec<_>>();
-    exchange_packets(client, server, false);
-    for stream_id in &stream_ids {
-        client.send_data(*stream_id, data).unwrap();
-    }
-    exchange_packets(client, server, false);
-    for stream_id in &stream_ids {
-        client.stream_close_send(*stream_id).unwrap();
-    }
-    exchange_packets(client, server, false);
-}
-
-fn connect() -> (Http3Client, Http3Server) {
-    let cp = ConnectionParameters::default()
-        .max_streams(STREAM_TYPE, STREAMS_MAX)
-        .pmtud(false)
-        .pacing(false)
-        .mlkem(false)
-        .sni_slicing(false);
-    let h3p = Http3Parameters::default().connection_parameters(cp);
-    let mut client = http3_client_with_params(h3p.clone());
-    let mut server = http3_server_with_params(h3p);
-    exchange_packets(&mut client, &mut server, true);
-    (client, server)
-}
+const ZERO: Duration = Duration::from_millis(0);
+const JITTER: Duration = Duration::from_millis(10);
 
 fn criterion_benchmark(c: &mut Criterion) {
     fixture_init();
 
-    for (streams, data_size) in [(1_000, 1), (1_000, 1_000)] {
-        let mut group = c.benchmark_group(format!("{streams} streams of {data_size} bytes"));
+    for (streams, data_size) in [(1usize, 1_000usize), (1_000, 1), (1_000, 1_000)] {
+        let setup = || {
+            let nodes = boxed![
+                Node::default_client(boxed![Requests::new(streams, data_size)]),
+                TailDrop::dsl_uplink(),
+                RandomDelay::new(ZERO..JITTER),
+                Node::default_server(boxed![Responses::new(streams, data_size)]),
+                TailDrop::dsl_uplink(),
+                RandomDelay::new(ZERO..JITTER),
+            ];
+            Simulator::new("", nodes).setup()
+        };
+        let routine = |sim: ReadySimulator| black_box(sim.run());
+
+        let mut group = c.benchmark_group(format!("{streams}-streams/each-{data_size}-bytes"));
+
+        // Benchmark with wallclock time, i.e. measure the compute efficiency.
+        group.bench_function("wallclock-time", |b| {
+            b.iter_batched(setup, routine, criterion::BatchSize::SmallInput);
+        });
 
-        // High variance benchmark. Increase default sample size (100).
-        group.sample_size(500);
+        // Benchmark with simulated time, i.e. measure the network protocol
+        // efficiency.
+        //
+        // Note: Given that this is using simulated time, we can measure actual
+        // throughput.
+        group.throughput(Throughput::Bytes((streams * data_size) as u64));
+        group.bench_function("simulated-time", |b| {
+            b.iter_custom(|iters| {
+                let mut d_sum = Duration::ZERO;
+                for _i in 0..iters {
+                    d_sum += setup().run();
+                }
 
-        group.bench_function("multistream", |b| {
-            let data = vec![0; data_size];
-            b.iter_batched_ref(
-                connect,
-                |_| black_box(|(client, server)| use_streams(client, server, streams, &data)),
-                BatchSize::SmallInput,
-            );
+                d_sum
+            });
         });
+
         group.finish();
     }
+
+    Criterion::default().configure_from_args().final_summary();
 }
 
 criterion_group!(benches, criterion_benchmark);

test-fixture/src/sim/connection.rs

@@ -20,20 +20,9 @@ use neqo_transport::{
 
 use crate::{
     boxed,
-    sim::{self, Rng},
+    sim::{self, GoalStatus, Rng},
 };
 
-/// The status of the processing of an event.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum GoalStatus {
-    /// The event didn't result in doing anything; the goal is waiting for something.
-    Waiting,
-    /// An action was taken as a result of the event.
-    Active,
-    /// The goal was accomplished.
-    Done,
-}
-
 /// A goal for the connection.
 /// Goals can be accomplished in any order.
 pub trait Goal: Debug {