mod dry;
mod endpoint;
mod mailbox;
mod notes;
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering, fence};
use std::time::Duration;
use plughost_core::FailureKind;
use plughost_core::ipc::shared::realtime::Ring;
pub use endpoint::{FallbackReason, RealtimeEndpoint, RealtimeOutput};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Fallback {
Silence,
Dry,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct RealtimeConfig {
pub quantum: usize,
pub latency: usize,
pub fallback: Fallback,
}
impl RealtimeConfig {
#[must_use]
pub const fn new(quantum: usize) -> RealtimeConfig {
RealtimeConfig {
quantum,
latency: 1,
fallback: Fallback::Silence,
}
}
#[must_use]
pub const fn with_latency(mut self, latency: usize) -> RealtimeConfig {
self.latency = latency;
self
}
#[must_use]
pub const fn with_fallback(mut self, fallback: Fallback) -> RealtimeConfig {
self.fallback = fallback;
self
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct RealtimeFailure {
pub slot: Option<usize>,
pub kind: FailureKind,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct RealtimeStatus {
pub running: bool,
pub resync: bool,
pub callbacks: u64,
pub processed: u64,
pub missed: u64,
pub overflows: u64,
pub size_mismatches: u64,
pub failures: u64,
pub last_failure: Option<RealtimeFailure>,
pub late: u64,
pub non_finite_outputs: u64,
pub dropped_events: u64,
pub latency: u32,
pub stalled: Duration,
}
const KINDS: [FailureKind; 17] = [
FailureKind::InvalidInput,
FailureKind::Unsupported,
FailureKind::NotFound,
FailureKind::Load,
FailureKind::Configuration,
FailureKind::NotPrepared,
FailureKind::Closed,
FailureKind::RestartRequired,
FailureKind::EditorOpen,
FailureKind::StateMismatch,
FailureKind::State,
FailureKind::Processing,
FailureKind::Editor,
FailureKind::Host,
FailureKind::Protocol,
FailureKind::Crashed,
FailureKind::TimedOut,
];
#[derive(Default)]
pub(crate) struct State {
running: AtomicBool,
closed: AtomicBool,
generation: AtomicU64,
halted: AtomicU64,
inside: AtomicU64,
resync: AtomicBool,
callbacks: AtomicU64,
processed: AtomicU64,
missed: AtomicU64,
overflows: AtomicU64,
size_mismatches: AtomicU64,
failures: AtomicU64,
non_finite_outputs: AtomicU64,
last_failure: AtomicU64,
dropped_events: AtomicU64,
latency: AtomicU32,
dry_delay: AtomicU64,
dry: mailbox::Mailbox<dry::DryDelay>,
ring: mailbox::Mailbox<Ring>,
}
impl State {
fn count(counter: &AtomicU64) {
counter.fetch_add(1, Ordering::Relaxed);
}
fn fail(&self, slot: Option<usize>, kind: FailureKind) {
Self::count(&self.failures);
let kind = KINDS.iter().position(|&known| known == kind).unwrap_or(14) as u64 + 1;
let slot = slot.map_or(0, |slot| slot as u64 + 1);
self.last_failure
.store(kind << 32 | slot & u64::from(u32::MAX), Ordering::Relaxed);
self.resync.store(true, Ordering::Relaxed);
}
fn last_failure(&self) -> Option<RealtimeFailure> {
let stored = self.last_failure.load(Ordering::Relaxed);
let kind = *KINDS.get(((stored >> 32) as usize).checked_sub(1)?)?;
let slot = (stored & u64::from(u32::MAX)).checked_sub(1);
Some(RealtimeFailure {
slot: slot.map(|slot| slot as usize),
kind,
})
}
pub(crate) fn status(&self, late: u64, stalled: Duration, added: u32) -> RealtimeStatus {
let load = |counter: &AtomicU64| counter.load(Ordering::Relaxed);
RealtimeStatus {
running: self.running.load(Ordering::Acquire),
resync: self.resync.load(Ordering::Relaxed),
callbacks: load(&self.callbacks),
processed: load(&self.processed),
missed: load(&self.missed),
overflows: load(&self.overflows),
size_mismatches: load(&self.size_mismatches),
failures: load(&self.failures),
last_failure: self.last_failure(),
late,
non_finite_outputs: load(&self.non_finite_outputs),
dropped_events: load(&self.dropped_events),
latency: self.latency.load(Ordering::Relaxed).saturating_add(added),
stalled,
}
}
pub(crate) fn running(&self) -> bool {
self.running.load(Ordering::Acquire)
}
pub(crate) fn start(&self, generation: u64, latency: u32, dry_delay: u64) {
self.latency.store(latency, Ordering::Relaxed);
self.dry_delay.store(dry_delay, Ordering::Relaxed);
self.resync.store(false, Ordering::Relaxed);
self.generation.store(generation, Ordering::Release);
self.running.store(true, Ordering::Release);
}
fn enter(&self) -> Call<'_> {
self.inside.fetch_add(1, Ordering::Relaxed);
fence(Ordering::SeqCst);
Call(self)
}
fn halted(&self, generation: u64) -> bool {
self.halted.load(Ordering::Relaxed) == generation
}
fn exclude(&self) {
self.halted.store(self.generation(), Ordering::Relaxed);
fence(Ordering::SeqCst);
let inside = self.inside.load(Ordering::Acquire);
while inside % 2 == 1 && self.inside.load(Ordering::Acquire) == inside {
std::thread::yield_now();
}
}
pub(crate) fn halt(&self) {
self.resync.store(true, Ordering::Relaxed);
self.exclude();
}
pub(crate) fn stop(&self) {
self.running.store(false, Ordering::Release);
self.exclude();
self.reclaim();
}
pub(crate) fn suspend(&self) {
self.resync.store(true, Ordering::Relaxed);
self.exclude();
}
pub(crate) fn reclaim(&self) {
self.dry.reclaim();
self.ring.reclaim();
}
pub(crate) fn close(&self) {
self.closed.store(true, Ordering::Release);
self.stop();
}
pub(crate) fn generation(&self) -> u64 {
self.generation.load(Ordering::Relaxed)
}
pub(crate) fn send_dry(&self, delay: Box<dry::DryDelay>) {
self.dry.send(delay);
}
pub(crate) fn send_ring(&self, ring: Box<Ring>) {
self.ring.send(ring);
}
}
struct Call<'a>(&'a State);
impl Drop for Call<'_> {
fn drop(&mut self) {
self.0.inside.fetch_add(1, Ordering::Release);
}
}
pub(crate) use dry::DryDelay;
#[cfg(test)]
mod tests;