use crate::{handoff_span::record, wait::NotifyResult};
#[derive(
::core::clone::Clone,
::core::marker::Copy,
::core::fmt::Debug,
::core::cmp::PartialEq,
::core::cmp::Eq,
)]
pub enum ChannelDirection {
Send,
Receive,
}
#[derive(
::core::clone::Clone,
::core::marker::Copy,
::core::fmt::Debug,
::core::default::Default,
::core::cmp::PartialEq,
::core::cmp::Eq,
)]
pub struct ChannelCounters {
calls: u64,
transfers: u64,
failed_calls: u64,
park_calls: u64,
park_returns: u64,
pub(crate) parks: u64,
retries: u64,
resumed_transfers: u64,
resumed_exits: u64,
selected_notifications: u64,
stored_notifications: u64,
closed_notifications: u64,
ineligible_notifications: u64,
}
impl ChannelCounters {
pub fn calls(&self) -> u64 {
self.calls
}
pub fn transfers(&self) -> u64 {
self.transfers
}
pub fn failed_calls(&self) -> u64 {
self.failed_calls
}
pub fn park_calls(&self) -> u64 {
self.park_calls
}
pub fn park_returns(&self) -> u64 {
self.park_returns
}
pub fn parks(&self) -> u64 {
self.parks
}
pub fn retries(&self) -> u64 {
self.retries
}
pub fn resumed_transfers(&self) -> u64 {
self.resumed_transfers
}
pub fn resumed_exits(&self) -> u64 {
self.resumed_exits
}
pub fn selected_notifications(&self) -> u64 {
self.selected_notifications
}
pub fn stored_notifications(&self) -> u64 {
self.stored_notifications
}
pub fn closed_notifications(&self) -> u64 {
self.closed_notifications
}
pub fn ineligible_notifications(&self) -> u64 {
self.ineligible_notifications
}
}
pub(crate) struct ChannelCall {
direction: ChannelDirection,
returned: bool,
transferred: bool,
}
impl ChannelCall {
pub(crate) fn new(direction: ChannelDirection) -> Self {
record(|profile| profile.channels[direction as usize].calls += 1);
Self {
direction,
returned: false,
transferred: false,
}
}
pub(crate) fn success(&mut self) {
record(|profile| {
let counts = &mut profile.channels[self.direction as usize];
counts.transfers += 1;
counts.resumed_transfers += u64::from(self.returned);
});
self.returned = false;
self.transferred = true;
}
pub(crate) fn miss(&mut self) {
if self.returned {
record(|profile| profile.channels[self.direction as usize].retries += 1);
self.returned = false;
}
}
pub(crate) fn park(&self) {
record(|profile| profile.channels[self.direction as usize].park_calls += 1);
}
pub(crate) fn returned(&mut self) {
record(|profile| profile.channels[self.direction as usize].park_returns += 1);
self.returned = true;
}
}
impl Drop for ChannelCall {
fn drop(&mut self) {
record(|profile| {
let counts = &mut profile.channels[self.direction as usize];
counts.failed_calls += u64::from(!self.transferred);
counts.resumed_exits += u64::from(self.returned);
});
}
}
pub(crate) fn notified(direction: ChannelDirection, outcome: NotifyResult, eligible: bool) {
record(|profile| {
let counts = &mut profile.channels[direction as usize];
match outcome {
NotifyResult::Woke => counts.selected_notifications += 1,
NotifyResult::Stored => counts.stored_notifications += 1,
NotifyResult::Closed => counts.closed_notifications += 1,
}
counts.ineligible_notifications += u64::from(!eligible);
});
}
#[cfg(test)]
#[path = "handoff_channel_test.rs"]
mod handoff_channel_test;