more throughput benchmarks

1 files changed, 40 insertions, 11 deletions

diff --git a/benches/criterion.rs b/benches/criterion.rs
index 64a3cc2..e4e6c94 100644
--- a/benches/criterion.rs
+++ b/benches/criterion.rs
@@ -5,11 +5,12 @@ extern crate x25519_dalek;
 extern crate rand;
 extern crate snow;
 
-use criterion::Criterion;
-use wireguard::protocol::Peer;
+use criterion::{Benchmark, Criterion, Throughput};
+use wireguard::protocol::{Peer, Session};
 use wireguard::noise::Noise;
 use x25519_dalek::{generate_secret, generate_public};
 use rand::OsRng;
+use std::time::Duration;
 
 struct Keypair {
     pub private: [u8; 32],
@@ -48,32 +49,60 @@ fn connected_peers() -> (Peer, [u8; 32], Peer, [u8; 32]) {
     let len = responder.write_message(&[], &mut buf).unwrap();
     let _   = initiator.read_message(&buf[..len], &mut []).unwrap();
 
-    peer_init.sessions.current = Some(initiator.into_transport_mode().unwrap().into());
-    peer_resp.sessions.current = Some(responder.into_transport_mode().unwrap().into());
+    let mut init_session = Session::from(initiator.into_transport_mode().unwrap());
+    let     resp_session = Session::with_their_index(responder.into_transport_mode().unwrap(), init_session.our_index);
+    init_session.their_index = resp_session.our_index;
+
+    peer_init.sessions.current = Some(init_session);
+    peer_init.info.endpoint = Some(([127, 0, 0, 1], 443).into());
     peer_init.info.pub_key = resp_keys.public;
+
+    peer_resp.sessions.current = Some(resp_session);
+    peer_resp.info.endpoint = Some(([127, 0, 0, 1], 443).into());
     peer_resp.info.pub_key = init_keys.public;
+
     (peer_init, init_keys.private, peer_resp, resp_keys.private)
 }
 
-fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("peer_handshake_initialization", |b| {
+fn benchmarks(c: &mut Criterion) {
+    c.bench("peer_handshake_initialization", Benchmark::new("peer_handshake_initialization", |b| {
         let mut peer = Peer::default();
         b.iter(move || {
             peer.initiate_new_session(&[1u8; 32]).unwrap()
         });
-    });
+    }).throughput(Throughput::Elements(1)));
 
-    c.bench_function("peer_handshake_response", |b| {
+    c.bench("peer_handshake_response", Benchmark::new("peer_handshake_response", |b| {
         let (mut peer_init, init_priv, mut peer_resp, resp_priv) = connected_peers();
         let (init, _) = peer_init.initiate_new_session(&init_priv).expect("initiate");
         let addr = ([127, 0, 0, 1], 443).into();
         b.iter(move || {
             peer_resp.last_handshake_tai64n = None;
             let handshake = Peer::process_incoming_handshake(&resp_priv, &init).unwrap();
-            peer_resp.complete_incoming_handshake(, handshake).expect("second half");
+            peer_resp.complete_incoming_handshake(addr, handshake).expect("second half");
+        });
+    }).throughput(Throughput::Elements(1)));
+
+    c.bench("peer_transport_outgoing", Benchmark::new("peer_transport_outgoing", |b| {
+        let (mut peer_init, init_priv, mut peer_resp, resp_priv) = connected_peers();
+        b.iter(move || {
+            peer_init.handle_outgoing_transport(&[1u8; 1420]).expect("handle_outgoing_transport")
+        });
+    }).throughput(Throughput::Bytes(1452)));
+
+    c.bench("peer_transport_incoming", Benchmark::new("peer_transport_incoming", |b| {
+        let (mut peer_init, init_priv, mut peer_resp, resp_priv) = connected_peers();
+        b.iter_with_setup(move || {
+            peer_init.handle_outgoing_transport(&[1u8; 1420]).expect("SETUP handle_outgoing_transport")
+        }, move |(addr, packet)| {
+            peer_resp.handle_incoming_transport(addr, &packet).expect("handle_incoming_transport")
         });
-    });
+    }).throughput(Throughput::Bytes(1452)));
+}
+
+fn custom_criterion() -> Criterion {
+    Criterion::default().warm_up_time(Duration::new(1, 0)).measurement_time(Duration::new(3, 0))
 }
 
-criterion_group!(benches, criterion_benchmark);
+criterion_group!(name = benches; config = custom_criterion(); targets = benchmarks);
 criterion_main!(benches);