129 lines
3.5 KiB
Rust
129 lines
3.5 KiB
Rust
//! Core operation benchmarks
|
|
//!
|
|
//! Measures the fundamental performance of basic announcement operations:
|
|
//! - Channel creation overhead
|
|
//! - Listener creation cost
|
|
//! - Announcement without listeners
|
|
//! - Try-listen operations (hit and miss cases)
|
|
//! - Status check operations
|
|
|
|
use announcement::Announcement;
|
|
use criterion::{criterion_group, criterion_main, Criterion};
|
|
use std::hint::black_box;
|
|
|
|
/// Benchmark: Create a new announcement channel
|
|
fn bench_channel_creation(c: &mut Criterion) {
|
|
c.bench_function("core/channel_creation", |b| {
|
|
b.iter(|| {
|
|
let (_tx, _announcement) = Announcement::<i32>::new();
|
|
});
|
|
});
|
|
}
|
|
|
|
/// Benchmark: Create a listener from an existing announcement
|
|
fn bench_listener_creation(c: &mut Criterion) {
|
|
let (_tx, announcement) = Announcement::<i32>::new();
|
|
|
|
c.bench_function("core/listener_creation", |b| {
|
|
b.iter(|| black_box(announcement.listener()));
|
|
});
|
|
}
|
|
|
|
/// Benchmark: Announce with no listeners attached
|
|
fn bench_announce_no_listeners(c: &mut Criterion) {
|
|
c.bench_function("core/announce_no_listeners", |b| {
|
|
b.iter(|| {
|
|
let (tx, _) = Announcement::<i32>::new();
|
|
tx.announce(black_box(42)).unwrap();
|
|
});
|
|
});
|
|
}
|
|
|
|
/// Benchmark: try_listen when value is available (cache hit)
|
|
fn bench_try_listen_hit(c: &mut Criterion) {
|
|
let (tx, announcement) = Announcement::new();
|
|
tx.announce(42).unwrap();
|
|
let listener = announcement.listener();
|
|
|
|
c.bench_function("core/try_listen_hit", |b| {
|
|
b.iter(|| {
|
|
black_box(listener.try_listen());
|
|
});
|
|
});
|
|
}
|
|
|
|
/// Benchmark: try_listen when no value available (cache miss)
|
|
fn bench_try_listen_miss(c: &mut Criterion) {
|
|
let (_tx, announcement) = Announcement::<i32>::new();
|
|
let listener = announcement.listener();
|
|
|
|
c.bench_function("core/try_listen_miss", |b| {
|
|
b.iter(|| {
|
|
black_box(listener.try_listen());
|
|
});
|
|
});
|
|
}
|
|
|
|
/// Benchmark: Check is_announced status
|
|
fn bench_is_announced(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("core/is_announced");
|
|
|
|
// Not yet announced
|
|
let (_tx_not, announcement_not) = Announcement::<i32>::new();
|
|
group.bench_function("before_announce", |b| {
|
|
b.iter(|| {
|
|
black_box(announcement_not.is_announced());
|
|
});
|
|
});
|
|
|
|
// Already announced
|
|
let (tx, announcement_yes) = Announcement::<i32>::new();
|
|
let _result = tx.announce(42);
|
|
group.bench_function("after_announce", |b| {
|
|
b.iter(|| {
|
|
black_box(announcement_yes.is_announced());
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
/// Benchmark: Check is_closed status
|
|
fn bench_is_closed(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("core/is_closed");
|
|
|
|
// Not yet closed
|
|
let (_tx, announcement) = Announcement::<i32>::new();
|
|
group.bench_function("announcer_alive", |b| {
|
|
b.iter(|| {
|
|
black_box(announcement.is_closed());
|
|
});
|
|
});
|
|
|
|
// After dropping announcer
|
|
let announcement_closed = {
|
|
let (tx, announcement) = Announcement::<i32>::new();
|
|
drop(tx);
|
|
announcement
|
|
};
|
|
group.bench_function("announcer_dropped", |b| {
|
|
b.iter(|| {
|
|
black_box(announcement_closed.is_closed());
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
criterion_group!(
|
|
benches,
|
|
bench_channel_creation,
|
|
bench_listener_creation,
|
|
bench_announce_no_listeners,
|
|
bench_try_listen_hit,
|
|
bench_try_listen_miss,
|
|
bench_is_announced,
|
|
bench_is_closed,
|
|
);
|
|
criterion_main!(benches);
|