105 lines
3.4 KiB
Rust
105 lines
3.4 KiB
Rust
use std::{
|
|
io::BufReader,
|
|
sync::{
|
|
atomic::{AtomicBool, Ordering},
|
|
Arc,
|
|
},
|
|
};
|
|
|
|
use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
|
|
use rustls::sign::CertifiedKey;
|
|
use rustls_resolver::channel;
|
|
|
|
fn prepare_key() -> CertifiedKey {
|
|
let certfile = std::fs::File::open("./out/example.crt").unwrap();
|
|
let mut reader = BufReader::new(certfile);
|
|
let certs = rustls_pemfile::certs(&mut reader)
|
|
.map(|res| res.map(|c| rustls::Certificate(c.to_vec())))
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.unwrap();
|
|
|
|
let keyfile = std::fs::File::open("./out/example.key").unwrap();
|
|
let mut reader = BufReader::new(keyfile);
|
|
let private_key = rustls_pemfile::private_key(&mut reader).unwrap().unwrap();
|
|
|
|
let private_key =
|
|
rustls::sign::any_supported_type(&rustls::PrivateKey(Vec::from(private_key.secret_der())))
|
|
.unwrap();
|
|
|
|
CertifiedKey::new(certs, private_key)
|
|
}
|
|
|
|
fn parallel_bench<const N: usize>(c: &mut Criterion, name: &str, writer: bool) {
|
|
let mut group = c.benchmark_group(name);
|
|
|
|
for i in [1u64, 2, 4, 8, 16, 32, 64].iter() {
|
|
group.bench_with_input(BenchmarkId::from_parameter(i), i, |b, i| {
|
|
let key = prepare_key();
|
|
let (tx, rx) = channel::<N>(key.clone());
|
|
|
|
let go = Arc::new(AtomicBool::new(true));
|
|
|
|
let mut handles = (0..*i)
|
|
.map(|_| {
|
|
let rx = rx.clone();
|
|
let go = go.clone();
|
|
std::thread::spawn(move || {
|
|
while go.load(Ordering::Relaxed) {
|
|
let _key = black_box(rx.read());
|
|
}
|
|
})
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
if writer {
|
|
let go = go.clone();
|
|
handles.push(std::thread::spawn(move || {
|
|
while go.load(Ordering::Relaxed) {
|
|
tx.update(key.clone())
|
|
}
|
|
}));
|
|
}
|
|
|
|
b.iter(|| {
|
|
let _key = black_box(rx.read());
|
|
});
|
|
|
|
go.store(false, Ordering::Relaxed);
|
|
|
|
for handle in handles {
|
|
handle.join().unwrap();
|
|
}
|
|
});
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
pub fn criterion_benchmark(c: &mut Criterion) {
|
|
c.bench_function("sequential_access", |b| {
|
|
let (_, rx) = channel::<1>(prepare_key());
|
|
|
|
b.iter(|| {
|
|
let _key = black_box(rx.read());
|
|
})
|
|
});
|
|
|
|
parallel_bench::<1>(c, "parallel_access_1", false);
|
|
parallel_bench::<2>(c, "parallel_access_2", false);
|
|
parallel_bench::<4>(c, "parallel_access_4", false);
|
|
parallel_bench::<8>(c, "parallel_access_8", false);
|
|
parallel_bench::<16>(c, "parallel_access_16", false);
|
|
parallel_bench::<32>(c, "parallel_access_32", false);
|
|
parallel_bench::<64>(c, "parallel_access_64", false);
|
|
|
|
parallel_bench::<1>(c, "parallel_access_with_writer_1", true);
|
|
parallel_bench::<2>(c, "parallel_access_with_writer_2", true);
|
|
parallel_bench::<4>(c, "parallel_access_with_writer_4", true);
|
|
parallel_bench::<8>(c, "parallel_access_with_writer_8", true);
|
|
parallel_bench::<16>(c, "parallel_access_with_writer_16", true);
|
|
parallel_bench::<32>(c, "parallel_access_with_writer_32", true);
|
|
parallel_bench::<64>(c, "parallel_access_with_writer_64", true);
|
|
}
|
|
|
|
criterion_group!(benches, criterion_benchmark);
|
|
criterion_main!(benches);
|