use core::fmt;
use core::time::Duration;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct LatencyStats {
pub samples: u64,
pub total: Duration,
pub min: Option<Duration>,
pub max: Option<Duration>,
}
impl LatencyStats {
pub fn record(&mut self, elapsed: Duration) {
self.samples += 1;
self.total += elapsed;
self.min = Some(self.min.map_or(elapsed, |min| min.min(elapsed)));
self.max = Some(self.max.map_or(elapsed, |max| max.max(elapsed)));
}
pub fn average(&self) -> Option<Duration> {
if self.samples == 0 {
return None;
}
let avg_nanos = (self.total.as_nanos() / self.samples as u128) as u64;
Some(Duration::from_nanos(avg_nanos))
}
pub fn average_micros(&self) -> u64 {
self.average().map_or(0, |duration| duration.as_micros() as u64)
}
pub fn min_micros(&self) -> u64 {
self.min.map_or(0, |duration| duration.as_micros() as u64)
}
pub fn max_micros(&self) -> u64 {
self.max.map_or(0, |duration| duration.as_micros() as u64)
}
pub fn reset(&mut self) {
*self = Self::default();
}
}
impl fmt::Display for LatencyStats {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "samples={}", self.samples)?;
if let Some(avg) = self.average() {
write!(
f,
" avg={} min={} max={}",
FormatDuration(avg),
FormatDuration(self.min.unwrap_or_default()),
FormatDuration(self.max.unwrap_or_default()),
)?;
}
Ok(())
}
}
impl defmt::Format for LatencyStats {
fn format(&self, fmt: defmt::Formatter) {
defmt::write!(
fmt,
"samples={} avg_us={} min_us={} max_us={}",
self.samples,
self.average_micros(),
self.min_micros(),
self.max_micros(),
);
}
}
struct FormatDuration(Duration);
impl fmt::Display for FormatDuration {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let duration = self.0;
if duration.as_secs() >= 1 {
write!(f, "{}.{:03}s", duration.as_secs(), duration.subsec_millis())
} else if duration.as_millis() >= 1 {
write!(f, "{}ms", duration.as_millis())
} else {
write!(f, "{}us", duration.as_micros())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
extern crate std;
#[test]
fn tracks_min_max_total_and_average() {
let mut stats = LatencyStats::default();
assert_eq!(stats.average(), None);
stats.record(Duration::from_micros(100));
stats.record(Duration::from_micros(200));
stats.record(Duration::from_micros(150));
assert_eq!(stats.samples, 3);
assert_eq!(stats.total, Duration::from_micros(450));
assert_eq!(stats.min, Some(Duration::from_micros(100)));
assert_eq!(stats.max, Some(Duration::from_micros(200)));
assert_eq!(stats.average(), Some(Duration::from_micros(150)));
}
#[test]
fn reset_clears_statistics() {
let mut stats = LatencyStats::default();
stats.record(Duration::from_micros(10));
stats.reset();
assert_eq!(stats, LatencyStats::default());
}
#[cfg(feature = "std")]
fn formats_durations() {
use std::string::ToString;
assert_eq!(FormatDuration(Duration::from_micros(5)).to_string(), "5us");
assert_eq!(
FormatDuration(Duration::from_millis(12)).to_string(),
"12ms"
);
assert_eq!(
FormatDuration(Duration::from_secs(3)).to_string(),
"3.000s"
);
}
}