bench_quic/
bench_quic.rs

1//! Transport CPU cost through the in-memory network (both endpoints on one thread, zero
2//! link delay, so wall time is the CPU of client + server + the simulator).
3//!
4//! `cargo run --release -p simoom-quic --example bench_quic [requests] [bulk_mb]`
5
6use simoom_quic::crypto::null::NullProvider;
7use simoom_quic::sim::{Link, Pair};
8use simoom_quic::tls::TlsProvider;
9use simoom_quic::{ConnHandle, Config, CryptoProvider};
10use simoom_tls::certgen::{self, CertParams};
11use simoom_tls::keys::{EcCurve, PrivateKey};
12use std::sync::Arc;
13use std::time::{Duration, Instant};
14
15fn link() -> Link {
16    Link { delay: Duration::ZERO, mtu: 1500, ..Link::default() }
17}
18
19fn providers(real: bool) -> (Arc<dyn CryptoProvider>, Arc<dyn CryptoProvider>) {
20    if !real {
21        return (Arc::new(NullProvider::new(1)), Arc::new(NullProvider::new(2)));
22    }
23    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
24    let ck = simoom_tls::CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap();
25    let s = TlsProvider::server(Arc::new(simoom_tls::ServerConfig::new(ck).with_alpn(&[b"h3"])));
26    let mut roots = simoom_tls::x509::RootStore::empty();
27    roots.add_der(&ss.cert_der).unwrap();
28    let c = TlsProvider::client(Arc::new(simoom_tls::ClientConfig::new(roots).with_alpn(&[b"h3"])));
29    (Arc::new(c), Arc::new(s))
30}
31
32fn pair(real: bool) -> (Pair, ConnHandle, ConnHandle) {
33    let (cp, sp) = providers(real);
34    let mut c = Config::new(cp);
35    let mut s = Config::new(sp);
36    for x in [&mut c, &mut s] {
37        x.transport.max_data = 16 << 20;
38        x.transport.stream_window_bidi_local = 8 << 20;
39        x.transport.stream_window_bidi_remote = 8 << 20;
40        x.transport.send_buffer = 8 << 20;
41    }
42    let mut p = Pair::new(Arc::new(c), Arc::new(s), link(), 7);
43    p.batch = 16;
44    let ch = p.connect();
45    assert!(p.run_until(Duration::from_secs(10), |p| p.client.conn(ch).is_some_and(|c| c.is_established())
46        && p.server_conn().and_then(|s| p.server.conn(s)).is_some_and(|c| c.is_established())));
47    let sh = p.server_conn().unwrap();
48    p.run_for(Duration::from_millis(50));
49    (p, ch, sh)
50}
51
52/// `n` request/response exchanges of `size` bytes each way, `conc` in flight.
53fn small(real: bool, n: usize, size: usize, conc: usize) -> f64 {
54    let (mut p, c, s) = pair(real);
55    let req = vec![7u8; size];
56    let mut buf = vec![0u8; 65536];
57    let mut open: Vec<(u64, usize)> = Vec::new(); // (stream, bytes received back)
58    let mut started = 0;
59    let mut done = 0;
60    let mut server_got: std::collections::HashMap<u64, usize> = Default::default();
61    let t = Instant::now();
62    while done < n {
63        while open.len() < conc && started < n {
64            let Ok(id) = p.client.conn_mut(c).unwrap().open_bi() else { break };
65            p.client.conn_mut(c).unwrap().stream_send(id, &req, true).unwrap();
66            open.push((id, 0));
67            started += 1;
68        }
69        p.step();
70        // Server: read requests, answer when complete.
71        while let Some(e) = p.server.poll_event(s) {
72            if let simoom_quic::Event::StreamReadable(id) = e {
73                let conn = p.server.conn_mut(s).unwrap();
74                while let Ok((k, fin)) = conn.stream_recv(id, &mut buf) {
75                    *server_got.entry(id).or_default() += k;
76                    if fin {
77                        server_got.remove(&id);
78                        conn.stream_send(id, &req, true).unwrap();
79                        break;
80                    }
81                    if k == 0 {
82                        break;
83                    }
84                }
85            }
86        }
87        while let Some(e) = p.client.poll_event(c) {
88            if let simoom_quic::Event::StreamReadable(id) = e {
89                let conn = p.client.conn_mut(c).unwrap();
90                while let Ok((k, fin)) = conn.stream_recv(id, &mut buf) {
91                    if let Some(o) = open.iter_mut().find(|o| o.0 == id) {
92                        o.1 += k;
93                    }
94                    if fin {
95                        open.retain(|o| o.0 != id);
96                        done += 1;
97                        break;
98                    }
99                    if k == 0 {
100                        break;
101                    }
102                }
103            }
104        }
105    }
106    let us = t.elapsed().as_secs_f64() * 1e6 / n as f64;
107    let pk = p.client.conn(c).unwrap().stats().sent_packets + p.server.conn(s).unwrap().stats().sent_packets;
108    eprintln!("    ({n} exchanges, {:.2} packets per exchange)", pk as f64 / n as f64);
109    us
110}
111
112/// One stream of `mb` MiB client to server; returns MB/s.
113fn bulk(real: bool, mb: usize) -> (f64, u64) {
114    let (mut p, c, s) = pair(real);
115    let chunk = vec![1u8; 256 << 10];
116    let total = mb << 20;
117    let id = p.client.conn_mut(c).unwrap().open_uni().unwrap();
118    let mut sent = 0;
119    let mut got = 0;
120    let mut buf = vec![0u8; 256 << 10];
121    let t = Instant::now();
122    while got < total {
123        if sent < total {
124            let conn = p.client.conn_mut(c).unwrap();
125            let want = (total - sent).min(chunk.len());
126            if let Ok(k) = conn.stream_send(id, &chunk[..want], sent + want == total) {
127                sent += k;
128            }
129        }
130        p.step();
131        if let Some(conn) = p.server.conn_mut(s) {
132            while let Ok((k, fin)) = conn.stream_recv(id, &mut buf) {
133                got += k;
134                if fin || k == 0 {
135                    break;
136                }
137            }
138        }
139        while p.server.poll_event(s).is_some() {}
140        while p.client.poll_event(c).is_some() {}
141    }
142    let secs = t.elapsed().as_secs_f64();
143    (total as f64 / secs / 1e6, p.client.conn(c).unwrap().stats().lost_packets)
144}
145
146fn main() {
147    let args: Vec<usize> = std::env::args().skip(1).filter_map(|a| a.parse().ok()).collect();
148    let n = args.first().copied().unwrap_or(50_000);
149    let mb = args.get(1).copied().unwrap_or(200);
150    for real in [false, true] {
151        let name = if real { "TLS 1.3 (AES-128-GCM)" } else { "null crypto" };
152        let seq = small(real, n / 5, 100, 1);
153        let par = small(real, n, 100, 32);
154        let (tp, lost) = bulk(real, mb);
155        println!("{name}:");
156        println!("  request/response, 100 B each way, 1 in flight:  {seq:6.2} us per exchange (client + server + sim)");
157        println!("  request/response, 100 B each way, 32 in flight: {par:6.2} us per exchange");
158        println!("  bulk, one stream, {mb} MiB:                       {tp:7.1} MB/s (lost {lost})");
159    }
160}
bench_quic/bench_quic.rs

bench_quic/
bench_quic.rs
