chore: initial release v0.1.0

Runtime-agnostic oneshot broadcast channel for Rust.

benches/core.rs

@@ -0,0 +1,128 @@
+//! 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);