2016-02-05 15:58:32 +00:00
|
|
|
// VpnCloud - Peer-to-Peer VPN
|
2017-07-22 14:49:53 +00:00
|
|
|
// Copyright (C) 2015-2017 Dennis Schwerdel
|
2016-02-05 15:58:32 +00:00
|
|
|
// This software is licensed under GPL-3 or newer (see LICENSE.md)
|
|
|
|
|
2015-11-25 20:05:11 +00:00
|
|
|
use test::Bencher;
|
|
|
|
|
|
|
|
use std::str::FromStr;
|
2016-02-08 19:37:06 +00:00
|
|
|
use std::net::{UdpSocket, ToSocketAddrs, Ipv4Addr, SocketAddr, SocketAddrV4};
|
|
|
|
use std::os::unix::io::AsRawFd;
|
2015-11-25 20:05:11 +00:00
|
|
|
|
2016-08-08 07:34:13 +00:00
|
|
|
use super::MAGIC;
|
2016-02-08 19:37:06 +00:00
|
|
|
use super::cloud::GenericCloud;
|
2016-06-27 13:43:30 +00:00
|
|
|
use super::device::{Device, Type};
|
2016-08-08 07:34:13 +00:00
|
|
|
use super::udpmessage::{Message, encode, decode};
|
2015-12-22 13:43:02 +00:00
|
|
|
use super::crypto::{Crypto, CryptoMethod};
|
2015-11-25 20:05:11 +00:00
|
|
|
use super::ethernet::{Frame, SwitchTable};
|
|
|
|
use super::types::{Address, Table, Protocol};
|
|
|
|
use super::ip::Packet;
|
2016-02-08 19:37:06 +00:00
|
|
|
use super::util::now as util_now;
|
2016-06-30 08:05:37 +00:00
|
|
|
use super::poll::{self, Poll};
|
2015-11-25 20:05:11 +00:00
|
|
|
|
2015-12-22 13:43:02 +00:00
|
|
|
#[bench]
|
|
|
|
fn crypto_salsa20(b: &mut Bencher) {
|
2016-02-08 19:12:12 +00:00
|
|
|
Crypto::init();
|
2015-12-22 13:43:02 +00:00
|
|
|
let mut crypto = Crypto::from_shared_key(CryptoMethod::ChaCha20, "test");
|
|
|
|
let mut payload = [0; 1500];
|
|
|
|
let header = [0; 8];
|
|
|
|
let mut nonce_bytes = [0; 12];
|
|
|
|
b.iter(|| {
|
|
|
|
let len = crypto.encrypt(&mut payload, 1400, &mut nonce_bytes, &header);
|
|
|
|
assert!(crypto.decrypt(&mut payload[..len], &nonce_bytes, &header).is_ok())
|
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn crypto_aes256(b: &mut Bencher) {
|
2016-02-08 19:12:12 +00:00
|
|
|
Crypto::init();
|
2015-12-22 13:43:02 +00:00
|
|
|
if !Crypto::aes256_available() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
let mut crypto = Crypto::from_shared_key(CryptoMethod::AES256, "test");
|
|
|
|
let mut payload = [0; 1500];
|
|
|
|
let header = [0; 8];
|
|
|
|
let mut nonce_bytes = [0; 12];
|
|
|
|
b.iter(|| {
|
|
|
|
let len = crypto.encrypt(&mut payload, 1400, &mut nonce_bytes, &header);
|
|
|
|
assert!(crypto.decrypt(&mut payload[..len], &nonce_bytes, &header).is_ok());
|
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
|
|
|
}
|
2015-11-25 20:05:11 +00:00
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn message_encode(b: &mut Bencher) {
|
|
|
|
let mut crypto = Crypto::None;
|
2015-12-13 21:10:47 +00:00
|
|
|
let mut payload = [0; 1600];
|
|
|
|
let mut msg = Message::Data(&mut payload, 64, 1464);
|
|
|
|
let mut buf = [0; 1600];
|
2015-11-25 20:05:11 +00:00
|
|
|
b.iter(|| {
|
2016-08-08 07:34:13 +00:00
|
|
|
encode(&mut msg, &mut buf[..], MAGIC, &mut crypto);
|
2015-11-25 20:05:11 +00:00
|
|
|
});
|
2016-03-29 11:54:28 +00:00
|
|
|
b.bytes = 1400;
|
2015-11-25 20:05:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn message_decode(b: &mut Bencher) {
|
|
|
|
let mut crypto = Crypto::None;
|
2015-12-13 21:10:47 +00:00
|
|
|
let mut payload = [0; 1600];
|
|
|
|
let mut msg = Message::Data(&mut payload, 64, 1464);
|
|
|
|
let mut buf = [0; 1600];
|
2016-08-08 07:34:13 +00:00
|
|
|
let mut res = encode(&mut msg, &mut buf[..], MAGIC, &mut crypto);
|
2015-11-25 20:05:11 +00:00
|
|
|
b.iter(|| {
|
2016-08-08 07:34:13 +00:00
|
|
|
decode(&mut res, MAGIC, &mut crypto).unwrap();
|
2015-11-25 20:05:11 +00:00
|
|
|
});
|
2016-03-29 11:54:28 +00:00
|
|
|
b.bytes = 1400;
|
2015-11-25 20:05:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn switch_learn(b: &mut Bencher) {
|
2016-11-28 11:14:56 +00:00
|
|
|
let mut table = SwitchTable::new(10, 0);
|
2015-11-25 20:05:11 +00:00
|
|
|
let addr = Address::from_str("12:34:56:78:90:ab").unwrap();
|
|
|
|
let peer = "1.2.3.4:5678".to_socket_addrs().unwrap().next().unwrap();
|
|
|
|
b.iter(|| {
|
|
|
|
table.learn(addr.clone(), None, peer);
|
2016-03-29 11:54:28 +00:00
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
2015-11-25 20:05:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn switch_lookup(b: &mut Bencher) {
|
2016-11-28 11:14:56 +00:00
|
|
|
let mut table = SwitchTable::new(10, 0);
|
2015-11-25 20:05:11 +00:00
|
|
|
let addr = Address::from_str("12:34:56:78:90:ab").unwrap();
|
|
|
|
let peer = "1.2.3.4:5678".to_socket_addrs().unwrap().next().unwrap();
|
|
|
|
table.learn(addr.clone(), None, peer);
|
|
|
|
b.iter(|| {
|
|
|
|
table.lookup(&addr);
|
2016-03-29 11:54:28 +00:00
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
2015-11-25 20:05:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn ethernet_parse(b: &mut Bencher) {
|
2015-11-25 20:55:30 +00:00
|
|
|
let mut data = [0; 1500];
|
|
|
|
data[5] = 45;
|
2015-11-25 20:05:11 +00:00
|
|
|
b.iter(|| {
|
|
|
|
Frame::parse(&data).unwrap()
|
2016-03-29 11:54:28 +00:00
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
2015-11-25 20:05:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn ipv4_parse(b: &mut Bencher) {
|
|
|
|
let mut data = [0; 1500];
|
|
|
|
data[0] = 4*16;
|
|
|
|
b.iter(|| {
|
|
|
|
Packet::parse(&data).unwrap()
|
2016-03-29 11:54:28 +00:00
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
2015-11-25 20:05:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn ipv6_parse(b: &mut Bencher) {
|
|
|
|
let mut data = [0; 1500];
|
|
|
|
data[0] = 6*16;
|
|
|
|
b.iter(|| {
|
|
|
|
Packet::parse(&data).unwrap()
|
2016-03-29 11:54:28 +00:00
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
2015-11-25 20:05:11 +00:00
|
|
|
}
|
2016-02-08 19:37:06 +00:00
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn now(b: &mut Bencher) {
|
|
|
|
b.iter(|| {
|
|
|
|
util_now()
|
2016-03-29 11:54:28 +00:00
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
2016-02-08 19:37:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn epoll_wait(b: &mut Bencher) {
|
|
|
|
let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
|
2016-06-30 08:05:37 +00:00
|
|
|
let mut poll_handle = Poll::new(1).unwrap();
|
2016-02-08 19:37:06 +00:00
|
|
|
let fd = socket.as_raw_fd();
|
2016-06-30 08:05:37 +00:00
|
|
|
poll_handle.register(fd, poll::WRITE).unwrap();
|
2016-02-08 19:37:06 +00:00
|
|
|
b.iter(|| {
|
2016-06-30 08:05:37 +00:00
|
|
|
assert_eq!(poll_handle.wait(1000).unwrap().len(), 1)
|
2016-02-08 19:37:06 +00:00
|
|
|
});
|
2016-03-29 11:54:28 +00:00
|
|
|
b.bytes = 1400;
|
2016-02-08 19:37:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn handle_interface_data(b: &mut Bencher) {
|
2017-05-04 06:22:24 +00:00
|
|
|
let mut node = GenericCloud::<Frame, SwitchTable>::new(
|
2016-08-08 07:34:13 +00:00
|
|
|
MAGIC, Device::dummy("vpncloud0", "/dev/null", Type::Tap).unwrap(), 0,
|
2017-05-04 06:22:24 +00:00
|
|
|
SwitchTable::new(300, 10), 1800, true, true, vec![], Crypto::None, None
|
2016-02-08 19:37:06 +00:00
|
|
|
);
|
|
|
|
let mut data = [0; 1500];
|
|
|
|
data[105] = 45;
|
|
|
|
b.iter(|| {
|
|
|
|
node.handle_interface_data(&mut data, 100, 1400).unwrap()
|
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn handle_net_message(b: &mut Bencher) {
|
2017-05-04 06:22:24 +00:00
|
|
|
let mut node = GenericCloud::<Frame, SwitchTable>::new(
|
2016-08-08 07:34:13 +00:00
|
|
|
MAGIC, Device::dummy("vpncloud0", "/dev/null", Type::Tap).unwrap(), 0,
|
2017-05-04 06:22:24 +00:00
|
|
|
SwitchTable::new(300, 10), 1800, true, true, vec![], Crypto::None, None
|
2016-02-08 19:37:06 +00:00
|
|
|
);
|
|
|
|
let addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 1));
|
|
|
|
let mut data = [0; 1500];
|
|
|
|
data[105] = 45;
|
|
|
|
b.iter(|| {
|
2016-08-08 07:34:13 +00:00
|
|
|
node.handle_net_message(addr.clone(), Message::Data(&mut data, 0, 1400)).unwrap()
|
2016-02-08 19:37:06 +00:00
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
fn udp_send(b: &mut Bencher) {
|
|
|
|
let sock = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
|
|
let data = [0; 1400];
|
2016-06-29 06:43:39 +00:00
|
|
|
let addr = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 1);
|
2016-02-08 19:37:06 +00:00
|
|
|
b.iter(|| {
|
2016-06-29 06:43:39 +00:00
|
|
|
sock.send_to(&data, &addr).unwrap()
|
2016-02-08 19:37:06 +00:00
|
|
|
});
|
|
|
|
b.bytes = 1400;
|
|
|
|
}
|