use std::sync::Mutex;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Instant;
pub struct PpsTracker {
total: AtomicU64,
drops: AtomicU64,
window: Mutex<Window>,
}
struct Window {
last_total: u64,
last_at: Instant,
primed: bool,
last_pps: u64,
}
impl PpsTracker {
#[must_use]
pub fn new() -> Self {
Self {
total: AtomicU64::new(0),
drops: AtomicU64::new(0),
window: Mutex::new(Window {
last_total: 0,
last_at: Instant::now(),
primed: false,
last_pps: 0,
}),
}
}
#[inline]
pub fn record(&self, n: u64) {
self.total.fetch_add(n, Ordering::Relaxed);
}
#[inline]
pub fn record_drop(&self, n: u64) {
self.drops.fetch_add(n, Ordering::Relaxed);
}
#[inline]
pub fn total(&self) -> u64 {
self.total.load(Ordering::Relaxed)
}
#[inline]
pub fn drops(&self) -> u64 {
self.drops.load(Ordering::Relaxed)
}
pub fn snapshot_pps(&self) -> u64 {
let now = Instant::now();
let total = self.total();
let mut window = match self.window.lock() {
Ok(g) => g,
Err(poisoned) => poisoned.into_inner(),
};
if !window.primed {
window.last_total = total;
window.last_at = now;
window.primed = true;
return 0;
}
let elapsed = now.duration_since(window.last_at).as_secs_f64();
const MIN_SAMPLE_SECS: f64 = 1e-3;
if elapsed < MIN_SAMPLE_SECS {
return window.last_pps;
}
let delta_packets = total.saturating_sub(window.last_total);
let pps_f = (delta_packets as f64) / elapsed;
let pps = if pps_f.is_finite() && pps_f >= 0.0 {
pps_f as u64
} else {
0
};
window.last_total = total;
window.last_at = now;
window.last_pps = pps;
pps
}
}
impl Default for PpsTracker {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::thread;
use std::time::Duration;
#[test]
fn first_snapshot_is_zero() {
let t = PpsTracker::new();
t.record(100);
assert_eq!(t.snapshot_pps(), 0);
}
#[test]
fn second_snapshot_reports_rate() {
let t = PpsTracker::new();
t.snapshot_pps(); t.record(1000);
thread::sleep(Duration::from_millis(50));
let pps = t.snapshot_pps();
assert!(
(5_000..=100_000).contains(&pps),
"expected ~20kpps, got {pps}"
);
}
#[test]
fn lifetime_total_and_drops_track() {
let t = PpsTracker::new();
t.record(7);
t.record(3);
t.record_drop(2);
assert_eq!(t.total(), 10);
assert_eq!(t.drops(), 2);
}
#[test]
fn snapshot_idempotent_on_zero_delta() {
let t = PpsTracker::new();
t.snapshot_pps();
let pps = t.snapshot_pps();
assert_eq!(pps, 0);
}
#[test]
fn rapid_reread_is_idempotent_and_does_not_corrupt_baseline() {
let t = PpsTracker::new();
t.snapshot_pps(); t.record(1000);
thread::sleep(Duration::from_millis(50));
let first = t.snapshot_pps();
assert!(first > 0, "first spaced read should report a rate, got {first}");
let second = t.snapshot_pps();
assert_eq!(
second, first,
"rapid re-read must be idempotent (cached rate), got {second} vs {first}"
);
t.record(1000);
thread::sleep(Duration::from_millis(50));
let third = t.snapshot_pps();
assert!(
third > 0,
"baseline must survive the rapid re-read so the next sample is real, got {third}"
);
}
#[test]
fn handles_concurrent_updates() {
let t = std::sync::Arc::new(PpsTracker::new());
t.snapshot_pps();
let handles: Vec<_> = (0..8)
.map(|_| {
let t = std::sync::Arc::clone(&t);
thread::spawn(move || {
for _ in 0..1_000 {
t.record(1);
}
})
})
.collect();
for h in handles {
h.join().unwrap();
}
assert_eq!(t.total(), 8_000);
thread::sleep(Duration::from_millis(3));
let pps = t.snapshot_pps();
assert!(pps > 0, "8000 packets over a real window should report a rate, got {pps}");
}
}