Struct Pair

Source

pub struct Pair {Show 14 fields
    pub now: Instant,
    pub client: Endpoint,
    pub server: Endpoint,
    pub client_addr: SocketAddr,
    pub server_addr: SocketAddr,
    pub client_aliases: Vec<SocketAddr>,
    pub to_server: Link,
    pub to_client: Link,
    pub to_server_stats: LinkStats,
    pub to_client_stats: LinkStats,
    pub rng: Rng,
    pub accepted: Vec<ConnHandle>,
    pub batch: usize,
    pub tamper: Option<Box<dyn FnMut(bool, &mut Vec<u8>) -> bool>>,
    /* private fields */
}

Expand description

Two endpoints and the links between them.

Fields§

§now: Instant§client: Endpoint§server: Endpoint§client_addr: SocketAddr§server_addr: SocketAddr§client_aliases: Vec<SocketAddr>

Old client addresses that still reach the client (after a rebinding).

§to_server: Link§to_client: Link§to_server_stats: LinkStats§to_client_stats: LinkStats§rng: Rng§accepted: Vec<ConnHandle>

Server connections accepted so far.

§batch: usize

GSO batch size used when polling endpoints.

§tamper: Option<Box<dyn FnMut(bool, &mut Vec<u8>) -> bool>>

Optional hook to inspect or rewrite datagrams in flight; return false to drop.

Implementations§

Source §

impl Pair

Source

pub fn new( client_cfg: Arc<Config>, server_cfg: Arc<Config>, link: Link, seed: u64, ) -> Self

Examples found in repository ?

examples/bench_quic.rs (line 42)

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}

Source

pub fn connect(&mut self) -> ConnHandle

Starts a client connection to the server.

Examples found in repository ?

examples/bench_quic.rs (line 44)

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}

Source

pub fn step(&mut self) -> bool

Runs one step: send what is ready, then deliver the next datagram or fire the next timer. Returns false when nothing is left to do.

Examples found in repository ?

examples/bench_quic.rs (line 69)

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}

Source

pub fn step_until(&mut self, limit: Option<Instant>) -> bool

Like Pair::step, but never advances the clock past limit.

Source

pub fn run_until( &mut self, limit: Duration, cond: impl FnMut(&mut Pair) -> bool, ) -> bool

Steps until cond holds or limit of virtual time passes; returns whether it held.

Examples found in repository ?

examples/bench_quic.rs (lines 45-46)

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}

Source

pub fn run_for(&mut self, limit: Duration)

Runs until both sides are idle (no datagrams or timers due within limit).

Examples found in repository ?

examples/bench_quic.rs (line 48)

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}

Source

pub fn server_conn(&self) -> Option<ConnHandle>

The first accepted server connection.

Examples found in repository ?

examples/bench_quic.rs (line 46)

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}